blink_gc_plugin: detect singletons with embedded ScriptWrappables.

tools/clang/blink_gc_plugin/RecordInfo.cpp

 // 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.
 
 #include "Config.h"
 #include "RecordInfo.h"
 #include "clang/Sema/Sema.h"
 
 using namespace clang;
 using std::string;
@@ skipping 89 matching lines @@
   if (!tmpl_type)
     return 0;
 
   TemplateDecl* tmpl_decl = tmpl_type->getTemplateName().getAsTemplateDecl();
   if (!tmpl_decl)
     return 0;
 
   return dyn_cast_or_null<CXXRecordDecl>(tmpl_decl->getTemplatedDecl());
 }
 
+const Type* RecordInfo::GetPersistentArgumentType(bool& has_persistent_name) {
+  has_persistent_name =
+      Config::IsPersistent(name()) || Config::IsCrossThreadPersistent(name());
+  if (!has_persistent_name)
+    return nullptr;
+
+  // "Persistent" could refer to v8::Persistent, check the name space.
+  if (!IsInBlinkNamespace())
+    return nullptr;
+
+  TemplateArgs args;
+  if (!GetTemplateArgs(1, &args))
+    return nullptr;
+  return args[0];
+}
+
+bool RecordInfo::IsInBlinkNamespace() {
+  NamespaceDecl* ns = dyn_cast<NamespaceDecl>(record()->getDeclContext());
+  return ns && ns->getName() == "blink";
+}
+
 void RecordInfo::walkBases() {
   // This traversal is akin to CXXRecordDecl::forallBases()'s,
   // but without stepping over dependent bases -- these might also
   // have a "GC base name", so are to be included and considered.
   SmallVector<const CXXRecordDecl*, 8> queue;
 
   const CXXRecordDecl* base_record = record();
   while (true) {
     for (const auto& it : base_record->bases()) {
       const RecordType* type = it.getType()->getAs<RecordType>();
@@ skipping 387 matching lines @@
     // identifiable reason for it being true is the presence
     // of a safely ignorable class as a direct base,
     // or we're processing such an 'ignorable' class, then it does
     // not need finalization.
     does_need_finalization_ =
         record_->hasNonTrivialDestructor() ? kTrue : kFalse;
     if (!does_need_finalization_)
       return does_need_finalization_;
 
     CXXDestructorDecl* dtor = record_->getDestructor();
-    if (dtor && dtor->isUserProvided())
+    if (dtor && dtor->isUserProvided()) {
       return does_need_finalization_;
+    }
     for (Fields::iterator it = GetFields().begin();
          it != GetFields().end();
          ++it) {
-      if (it->second.edge()->NeedsFinalization())
+      if (it->second.edge()->NeedsFinalization()) {
         return does_need_finalization_;
+      }
     }
 
     for (Bases::iterator it = GetBases().begin();
          it != GetBases().end();
          ++it) {
-      if (it->second.info()->NeedsFinalization())
+      if (it->second.info()->NeedsFinalization()) {
         return does_need_finalization_;
+      }
     }
     // Destructor was non-trivial due to bases with destructors that
     // can be safely ignored. Hence, no need for finalization.
     does_need_finalization_ = kFalse;
   }
   return does_need_finalization_;
 }
 
 // A class needs tracing if:
 // - it is allocated on the managed heap,
@@ skipping 107 matching lines @@
       return new Member(ptr);
     return 0;
   }
 
   if (Config::IsWeakMember(info->name()) && info->GetTemplateArgs(1, &args)) {
     if (Edge* ptr = CreateEdge(args[0]))
       return new WeakMember(ptr);
     return 0;
   }
 
-  bool is_persistent = Config::IsPersistent(info->name());
-  if (is_persistent || Config::IsCrossThreadPersistent(info->name())) {
-    // Persistent might refer to v8::Persistent, so check the name space.
-    // TODO: Consider using a more canonical identification than names.
-    NamespaceDecl* ns =
-        dyn_cast<NamespaceDecl>(info->record()->getDeclContext());
-    if (!ns || ns->getName() != "blink")
-      return 0;
-    if (!info->GetTemplateArgs(1, &args))
-      return 0;
-    if (Edge* ptr = CreateEdge(args[0])) {
-      if (is_persistent)
+  bool has_persistent_name = false;
+  if (const Type* arg_type =
+          info->GetPersistentArgumentType(has_persistent_name)) {
+    if (Edge* ptr = CreateEdge(arg_type)) {
+      if (Config::IsPersistent(info->name()))
         return new Persistent(ptr);
       else
         return new CrossThreadPersistent(ptr);
     }
-    return 0;
+    return nullptr;
+  } else if (has_persistent_name) {
+    // Other Persistent type names are not relevant, like v8::Persistent<>.
+    return nullptr;
   }
 
   if (Config::IsGCCollection(info->name()) ||
       Config::IsWTFCollection(info->name())) {
     bool is_root = Config::IsPersistentGCCollection(info->name());
     bool on_heap = is_root || info->IsHeapAllocatedCollection();
     size_t count = Config::CollectionDimension(info->name());
     if (!info->GetTemplateArgs(count, &args))
       return 0;
     Collection* edge = new Collection(info, on_heap, is_root);
     for (TemplateArgs::iterator it = args.begin(); it != args.end(); ++it) {
       if (Edge* member = CreateEdge(*it)) {
         edge->members().push_back(member);
       }
       // TODO: Handle the case where we fail to create an edge (eg, if the
       // argument is a primitive type or just not fully known yet).
     }
     return edge;
   }
 
   return new Value(info);
 }