Refactor banned directory checking so Blink can opt into certain checks.

tools/clang/plugins/ChromeClassTester.cpp

 // 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 <algorithm>
@@ skipping 30 matching lines @@
       diagnostic_(instance.getDiagnostics()) {
   BuildBannedLists();
 }
 
 ChromeClassTester::~ChromeClassTester() {}
 
 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 (InBannedNamespace(tag))
+    return;
+
+  SourceLocation location = tag->getInnerLocStart();
+  LocationType location_type = ClassifyLocation(location);
+  if (location_type == LocationType::kThirdParty)
+    return;
 
   if (CXXRecordDecl* record = dyn_cast<CXXRecordDecl>(tag)) {
-    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);
+    CheckChromeClass(location_type, location, record);
   } else if (EnumDecl* enum_decl = dyn_cast<EnumDecl>(tag)) {
-    SourceLocation enum_location = enum_decl->getInnerLocStart();
-    if (InBannedDirectory(enum_location))
-      return;
-
     std::string base_name = enum_decl->getNameAsString();
+    // TODO(dcheng): This should probably consult a separate list.
     if (IsIgnoredType(base_name))
       return;
 
-    CheckChromeEnum(enum_location, enum_decl);
+    CheckChromeEnum(location_type, location, enum_decl);
   }
 }
 
 void ChromeClassTester::emitWarning(SourceLocation loc,
                                     const char* raw_error) {
   FullSourceLoc full(loc, instance().getSourceManager());
   std::string err;
   err = "[chromium-style] ";
   err += raw_error;
 
   DiagnosticIDs::Level level = getErrorLevel() == DiagnosticsEngine::Error
       ? DiagnosticIDs::Error : DiagnosticIDs::Warning;
 
   unsigned id = diagnostic().getDiagnosticIDs()->getCustomDiagID(level, err);
   DiagnosticBuilder builder = diagnostic().Report(full, id);
 
 }
 
-bool ChromeClassTester::InBannedDirectory(SourceLocation loc) {
+ChromeClassTester::LocationType ChromeClassTester::ClassifyLocation(
+    SourceLocation loc) {
   if (instance().getSourceManager().isInSystemHeader(loc))
-    return true;
+    return LocationType::kThirdParty;
 
   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;
+    return LocationType::kThirdParty;
   }
 
   // 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;
+    return LocationType::kThirdParty;
 
   // Don't complain about autogenerated protobuf files.
-  if (ends_with(filename, ".pb.h")) {
-    return true;
-  }
+  if (ends_with(filename, ".pb.h"))
+    return LocationType::kThirdParty;
 
 #if defined(LLVM_ON_UNIX)
   // Resolve the symlinktastic relative path and make it absolute.
   char resolvedPath[MAXPATHLEN];
   if (options_.no_realpath) {
     // Same reason as windows below, but we don't need to do
     // the '\\' manipulation on linux.
     filename.insert(filename.begin(), '/');
   } else if (realpath(filename.c_str(), resolvedPath)) {
     filename = resolvedPath;
@@ skipping 21 matching lines @@
     size_needed = WideCharToMultiByte(CP_UTF8, 0, full_utf16.data(), -1,
                                       nullptr, 0, nullptr, nullptr);
     filename.resize(size_needed);
     WideCharToMultiByte(CP_UTF8, 0, full_utf16.data(), -1, &filename[0],
                         size_needed, nullptr, nullptr);
   }
 
   std::replace(filename.begin(), filename.end(), '\\', '/');
 #endif
 
-  for (const std::string& allowed_dir : allowed_directories_) {
+  for (const std::string& blink_dir : blink_directories_) {
     // If any of the allowed directories occur as a component in filename,
     // this file is allowed.
-    assert(allowed_dir.front() == '/' && "Allowed dir must start with '/'");
-    assert(allowed_dir.back() == '/' && "Allowed dir must end with '/'");
+    assert(blink_dir.front() == '/' && "Allowed dir must start with '/'");
+    assert(blink_dir.back() == '/' && "Allowed dir must end with '/'");
 
-    if (filename.find(allowed_dir) != std::string::npos)
-      return false;
+    if (filename.find(blink_dir) != std::string::npos)
+      return LocationType::kBlink;
   }
 
   for (const std::string& banned_dir : banned_directories_) {
     // If any of the banned directories occur as a component in filename,
     // this file is rejected.
     assert(banned_dir.front() == '/' && "Banned dir must start with '/'");
     assert(banned_dir.back() == '/' && "Banned dir must end with '/'");
 
     if (filename.find(banned_dir) != std::string::npos)
-      return true;
+      return LocationType::kThirdParty;
   }
 
-  return false;
+  return LocationType::kChrome;
 }
 
 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();
-  }
+  if (!n.empty())
+    return banned_namespaces_.find(n) != banned_namespaces_.end();
 
   return false;
 }
 
 std::string ChromeClassTester::GetNamespace(const Decl* record) {
-  return GetNamespaceImpl(record->getDeclContext(), "");
+  return GetNamespaceImpl(record->getDeclContext(), std::string());
 }
 
 bool ChromeClassTester::HasIgnoredBases(const CXXRecordDecl* record) {
   for (const auto& base : record->bases()) {
     CXXRecordDecl* base_record = base.getType()->getAsCXXRecordDecl();
     if (!base_record)
       continue;
 
     const std::string& base_name = base_record->getQualifiedNameAsString();
     if (ignored_base_classes_.count(base_name) > 0)
@@ skipping 23 matching lines @@
         source_manager.getImmediateExpansionRange(record_location).first;
   }
 
   return false;
 }
 
 void ChromeClassTester::BuildBannedLists() {
   banned_namespaces_.emplace("std");
   banned_namespaces_.emplace("__gnu_cxx");
 
-  if (options_.enforce_in_thirdparty_webkit) {
-    allowed_directories_.emplace("/third_party/WebKit/");
-  }
+  blink_directories_.emplace("/third_party/WebKit/");
 
   banned_directories_.emplace("/third_party/");
   banned_directories_.emplace("/native_client/");
   banned_directories_.emplace("/breakpad/");
   banned_directories_.emplace("/courgette/");
   banned_directories_.emplace("/ppapi/");
   banned_directories_.emplace("/testing/");
   banned_directories_.emplace("/v8/");
   banned_directories_.emplace("/sdch/");
   banned_directories_.emplace("/frameworks/");
@@ skipping 87 matching lines @@
   }
 
   *filename = ploc.getFilename();
   return true;
 }
 
 DiagnosticsEngine::Level ChromeClassTester::getErrorLevel() {
   return diagnostic().getWarningsAsErrors() ? DiagnosticsEngine::Error
                                             : DiagnosticsEngine::Warning;
 }