Update from https://crrev.com/309717

tools/clang/blink_gc_plugin/Config.h

 // Copyright 2014 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.
 
 // This file defines the names used by GC infrastructure.
 
 // TODO: Restructure the name determination to use fully qualified names (ala,
 // blink::Foo) so that the plugin can be enabled for all of chromium. Doing so
 // would allow us to catch errors with structures outside of blink that might
 // have unsafe pointers to GC allocated blink structures.
 
 #ifndef TOOLS_BLINK_GC_PLUGIN_CONFIG_H_
 #define TOOLS_BLINK_GC_PLUGIN_CONFIG_H_
 
 #include "clang/AST/AST.h"
 #include "clang/AST/Attr.h"
 
 const char kNewOperatorName[] = "operator new";
 const char kCreateName[] = "create";
 const char kTraceName[] = "trace";
+const char kTraceImplName[] = "traceImpl";
 const char kFinalizeName[] = "finalizeGarbageCollectedObject";
 const char kTraceAfterDispatchName[] = "traceAfterDispatch";
 const char kRegisterWeakMembersName[] = "registerWeakMembers";
 const char kHeapAllocatorName[] = "HeapAllocator";
 const char kTraceIfNeededName[] = "TraceIfNeeded";
+const char kVisitorDispatcherName[] = "VisitorDispatcher";
 
 class Config {
  public:
   static bool IsMember(const std::string& name) {
     return name == "Member";
   }
 
   static bool IsWeakMember(const std::string& name) {
     return name == "WeakMember";
   }
@@ skipping 120 matching lines @@
 
   static bool IsIgnoreCycleAnnotated(clang::Decl* decl) {
     return IsAnnotated(decl, "blink_gc_plugin_ignore_cycle") ||
            IsIgnoreAnnotated(decl);
   }
 
   static bool IsVisitor(const std::string& name) {
     return name == "Visitor" || name == "VisitorHelper";
   }
 
-  static bool IsTraceMethod(clang::FunctionDecl* method,
-                            bool* isTraceAfterDispatch = 0) {
-    if (method->getNumParams() != 1)
-      return false;
-
-    const std::string& name = method->getNameAsString();
-    if (name != kTraceName && name != kTraceAfterDispatchName)
-      return false;
-
-    const clang::QualType& formal_type = method->getParamDecl(0)->getType();
+  static bool IsVisitorPtrType(const clang::QualType& formal_type) {
     if (!formal_type->isPointerType())
       return false;
 
     clang::CXXRecordDecl* pointee_type =
         formal_type->getPointeeType()->getAsCXXRecordDecl();
     if (!pointee_type)
       return false;
 
     if (!IsVisitor(pointee_type->getName()))
       return false;
 
-    if (isTraceAfterDispatch)
-      *isTraceAfterDispatch = (name == kTraceAfterDispatchName);
     return true;
   }
 
+  static bool IsVisitorDispatcherType(const clang::QualType& formal_type) {
+    if (const clang::SubstTemplateTypeParmType* subst_type =
+            clang::dyn_cast<clang::SubstTemplateTypeParmType>(
+                formal_type.getTypePtr())) {
+      if (IsVisitorPtrType(subst_type->getReplacementType())) {
+        // VisitorDispatcher template parameter substituted to Visitor*.
+        return true;
+      }
+    } else if (const clang::TemplateTypeParmType* parm_type =
+                   clang::dyn_cast<clang::TemplateTypeParmType>(
+                       formal_type.getTypePtr())) {
+      if (parm_type->getDecl()->getName() == kVisitorDispatcherName) {
+        // Unresolved, but its parameter name is VisitorDispatcher.
+        return false;
+      }
+    }
+
+    return IsVisitorPtrType(formal_type);
+  }
+
+  static bool IsTraceMethod(clang::FunctionDecl* method,
+                            bool* is_trace_after_dispatch) {
+    if (method->getNumParams() != 1)
+      return false;
+
+    const std::string& name = method->getNameAsString();
+    if (name != kTraceName && name != kTraceAfterDispatchName &&
+        name != kTraceImplName)
+      return false;
+
+    const clang::QualType& formal_type = method->getParamDecl(0)->getType();
+    if (name == kTraceImplName) {
+      if (!IsVisitorDispatcherType(formal_type))
+        return false;
+    } else if (!IsVisitorPtrType(formal_type)) {
+      return false;
+    }
+
+    if (is_trace_after_dispatch)
+      *is_trace_after_dispatch = (name == kTraceAfterDispatchName);
+
+    return true;
+  }
+
   static bool StartsWith(const std::string& str, const std::string& prefix) {
     if (prefix.size() > str.size())
       return false;
     return str.compare(0, prefix.size(), prefix) == 0;
   }
 
   static bool EndsWith(const std::string& str, const std::string& suffix) {
     if (suffix.size() > str.size())
       return false;
     return str.compare(str.size() - suffix.size(), suffix.size(), suffix) == 0;
   }
 };
 
 #endif  // TOOLS_BLINK_GC_PLUGIN_CONFIG_H_