The Tor Browser: comparison media/webrtc/trunk/tools/clang/plugins/ChromeClassTester.cpp

--1:000000000000
+:d51c01569f53
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+// A general interface for filtering and only acting on classes in Chromium C++
+// code.
+#include "ChromeClassTester.h"
+#include <sys/param.h>
+#include "clang/AST/AST.h"
+#include "clang/Basic/FileManager.h"
+#include "clang/Basic/SourceManager.h"
+using namespace clang;
+namespace {
+bool starts_with(const std::string& one, const std::string& two) {
+return one.compare(0, two.size(), two) == 0;
+}
+std::string lstrip(const std::string& one, const std::string& two) {
+if (starts_with(one, two))
+return one.substr(two.size());
+return one;
+}
+bool ends_with(const std::string& one, const std::string& two) {
+if (two.size() > one.size())
+return false;
+return one.compare(one.size() - two.size(), two.size(), two) == 0;
+}
+}  // namespace
+ChromeClassTester::ChromeClassTester(CompilerInstance& instance)
+: instance_(instance),
+diagnostic_(instance.getDiagnostics()) {
+BuildBannedLists();
+}
+ChromeClassTester::~ChromeClassTester() {}
+void ChromeClassTester::HandleTagDeclDefinition(TagDecl* tag) {
+pending_class_decls_.push_back(tag);
+}
+bool ChromeClassTester::HandleTopLevelDecl(DeclGroupRef group_ref) {
+for (size_t i = 0; i < pending_class_decls_.size(); ++i)
+CheckTag(pending_class_decls_[i]);
+pending_class_decls_.clear();
+return true;  // true means continue parsing.
+}
+void ChromeClassTester::CheckTag(TagDecl* tag) {
+// We handle class types here where we have semantic information. We can only
+// check structs/classes/enums here, but we get a bunch of nice semantic
+// information instead of just parsing information.
+if (CXXRecordDecl* record = dyn_cast<CXXRecordDecl>(tag)) {
+// If this is a POD or a class template or a type dependent on a
+// templated class, assume there's no ctor/dtor/virtual method
+// optimization that we can do.
+if (record->isPOD() ||
+record->getDescribedClassTemplate() ||
+record->getTemplateSpecializationKind() ||
+record->isDependentType())
+return;
+if (InBannedNamespace(record))
+return;
+SourceLocation record_location = record->getInnerLocStart();
+if (InBannedDirectory(record_location))
+return;
+// We sadly need to maintain a blacklist of types that violate these
+// rules, but do so for good reason or due to limitations of this
+// checker (i.e., we don't handle extern templates very well).
+std::string base_name = record->getNameAsString();
+if (IsIgnoredType(base_name))
+return;
+// We ignore all classes that end with "Matcher" because they're probably
+// GMock artifacts.
+if (ends_with(base_name, "Matcher"))
+return;
+CheckChromeClass(record_location, record);
+}
+}
+void ChromeClassTester::emitWarning(SourceLocation loc,
+const char* raw_error) {
+FullSourceLoc full(loc, instance().getSourceManager());
+std::string err;
+err = "[chromium-style] ";
+err += raw_error;
+DiagnosticsEngine::Level level =
+diagnostic().getWarningsAsErrors() ?
+DiagnosticsEngine::Error :
+DiagnosticsEngine::Warning;
+unsigned id = diagnostic().getCustomDiagID(level, err);
+DiagnosticBuilder builder = diagnostic().Report(full, id);
+}
+bool ChromeClassTester::InBannedNamespace(const Decl* record) {
+std::string n = GetNamespace(record);
+if (!n.empty()) {
+return std::find(banned_namespaces_.begin(), banned_namespaces_.end(), n)
+!= banned_namespaces_.end();
+}
+return false;
+}
+std::string ChromeClassTester::GetNamespace(const Decl* record) {
+return GetNamespaceImpl(record->getDeclContext(), "");
+}
+bool ChromeClassTester::InImplementationFile(SourceLocation record_location) {
+std::string filename;
+if (!GetFilename(record_location, &filename))
+return false;
+if (ends_with(filename, ".cc") || ends_with(filename, ".cpp") ||
+ends_with(filename, ".mm")) {
+return true;
+}
+return false;
+}
+void ChromeClassTester::BuildBannedLists() {
+banned_namespaces_.push_back("std");
+banned_namespaces_.push_back("__gnu_cxx");
+banned_namespaces_.push_back("WebKit");
+banned_directories_.push_back("third_party/");
+banned_directories_.push_back("native_client/");
+banned_directories_.push_back("breakpad/");
+banned_directories_.push_back("courgette/");
+banned_directories_.push_back("pdf/");
+banned_directories_.push_back("ppapi/");
+banned_directories_.push_back("usr/");
+banned_directories_.push_back("testing/");
+banned_directories_.push_back("googleurl/");
+banned_directories_.push_back("v8/");
+banned_directories_.push_back("dart/");
+banned_directories_.push_back("sdch/");
+banned_directories_.push_back("icu4c/");
+banned_directories_.push_back("frameworks/");
+// Don't check autogenerated headers.
+// Make puts them below $(builddir_name)/.../gen and geni.
+// Ninja puts them below OUTPUT_DIR/.../gen
+// Xcode has a fixed output directory for everything.
+banned_directories_.push_back("gen/");
+banned_directories_.push_back("geni/");
+banned_directories_.push_back("xcodebuild/");
+// You are standing in a mazy of twisty dependencies, all resolved by
+// putting everything in the header.
+banned_directories_.push_back("automation/");
+// Don't check system headers.
+banned_directories_.push_back("/Developer/");
+// Used in really low level threading code that probably shouldn't be out of
+// lined.
+ignored_record_names_.insert("ThreadLocalBoolean");
+// A complicated pickle derived struct that is all packed integers.
+ignored_record_names_.insert("Header");
+// Part of the GPU system that uses multiple included header
+// weirdness. Never getting this right.
+ignored_record_names_.insert("Validators");
+// Has a UNIT_TEST only constructor. Isn't *terribly* complex...
+ignored_record_names_.insert("AutocompleteController");
+ignored_record_names_.insert("HistoryURLProvider");
+// Because of chrome frame
+ignored_record_names_.insert("ReliabilityTestSuite");
+// Used over in the net unittests. A large enough bundle of integers with 1
+// non-pod class member. Probably harmless.
+ignored_record_names_.insert("MockTransaction");
+// Used heavily in ui_unittests and once in views_unittests. Fixing this
+// isn't worth the overhead of an additional library.
+ignored_record_names_.insert("TestAnimationDelegate");
+// Part of our public interface that nacl and friends use. (Arguably, this
+// should mean that this is a higher priority but fixing this looks hard.)
+ignored_record_names_.insert("PluginVersionInfo");
+}
+std::string ChromeClassTester::GetNamespaceImpl(const DeclContext* context,
+const std::string& candidate) {
+switch (context->getDeclKind()) {
+case Decl::TranslationUnit: {
+return candidate;
+}
+case Decl::Namespace: {
+const NamespaceDecl* decl = dyn_cast<NamespaceDecl>(context);
+std::string name_str;
+llvm::raw_string_ostream OS(name_str);
+if (decl->isAnonymousNamespace())
+OS << "<anonymous namespace>";
+else
+OS << *decl;
+return GetNamespaceImpl(context->getParent(),
+OS.str());
+}
+default: {
+return GetNamespaceImpl(context->getParent(), candidate);
+}
+}
+}
+bool ChromeClassTester::InBannedDirectory(SourceLocation loc) {
+std::string filename;
+if (!GetFilename(loc, &filename)) {
+// If the filename cannot be determined, simply treat this as a banned
+// location, instead of going through the full lookup process.
+return true;
+}
+// We need to special case scratch space; which is where clang does its
+// macro expansion. We explicitly want to allow people to do otherwise bad
+// things through macros that were defined due to third party libraries.
+if (filename == "<scratch space>")
+return true;
+// Don't complain about autogenerated protobuf files.
+if (ends_with(filename, ".pb.h")) {
+return true;
+}
+// We need to munge the paths so that they are relative to the repository
+// srcroot. We first resolve the symlinktastic relative path and then
+// remove our known srcroot from it if needed.
+char resolvedPath[MAXPATHLEN];
+if (realpath(filename.c_str(), resolvedPath)) {
+filename = resolvedPath;
+}
+// On linux, chrome is often checked out to /usr/local/google. Due to the
+// "usr" rule in banned_directories_, all diagnostics would be suppressed
+// in that case. As a workaround, strip that prefix.
+filename = lstrip(filename, "/usr/local/google");
+for (std::vector<std::string>::const_iterator it =
+banned_directories_.begin();
+it != banned_directories_.end(); ++it) {
+// If we can find any of the banned path components in this path, then
+// this file is rejected.
+size_t index = filename.find(*it);
+if (index != std::string::npos) {
+bool matches_full_dir_name = index == 0 || filename[index - 1] == '/';
+if ((*it)[0] == '/')
+matches_full_dir_name = true;
+if (matches_full_dir_name)
+return true;
+}
+}
+return false;
+}
+bool ChromeClassTester::IsIgnoredType(const std::string& base_name) {
+return ignored_record_names_.find(base_name) != ignored_record_names_.end();
+}
+bool ChromeClassTester::GetFilename(SourceLocation loc,
+std::string* filename) {
+const SourceManager& source_manager = instance_.getSourceManager();
+SourceLocation spelling_location = source_manager.getSpellingLoc(loc);
+PresumedLoc ploc = source_manager.getPresumedLoc(spelling_location);
+if (ploc.isInvalid()) {
+// If we're in an invalid location, we're looking at things that aren't
+// actually stated in the source.
+return false;
+}
+*filename = ploc.getFilename();
+return true;
+}

The Tor Browser / file comparison

comparison: media/webrtc/trunk/tools/clang/plugins/ChromeClassTester.cpp

media/webrtc/trunk/tools/clang/plugins/ChromeClassTester.cpp