gc plugin: remove ScriptWrappable destructor special case.

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"
 
 using namespace clang;
 using std::string;
 
@@ skipping 492 matching lines @@
     // Rely on hasNonTrivialDestructor(), but if the only
     // 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_;
 
-    // Processing a class with a safely-ignorable destructor.
-    NamespaceDecl* ns =
-        dyn_cast<NamespaceDecl>(record_->getDeclContext());
-    if (ns && Config::HasIgnorableDestructor(ns->getName(), name_)) {
-      does_need_finalization_ = kFalse;
-      return does_need_finalization_;
-    }
-
     CXXDestructorDecl* dtor = record_->getDestructor();
     if (dtor && dtor->isUserProvided())
       return does_need_finalization_;
     for (Fields::iterator it = GetFields().begin();
          it != GetFields().end();
          ++it) {
       if (it->second.edge()->NeedsFinalization())
         return does_need_finalization_;
     }
 
     for (Bases::iterator it = GetBases().begin();
          it != GetBases().end();
          ++it) {
       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,
 // - it is derived from a class that needs tracing, or
 // - it contains fields that need tracing.
-// TODO: Defining NeedsTracing based on whether a class defines a trace method
-// (of the proper signature) over approximates too much. The use of transition
-// types causes some classes to have trace methods without them needing to be
-// traced.
+//
 TracingStatus RecordInfo::NeedsTracing(Edge::NeedsTracingOption option) {
   if (IsGCAllocated())
     return TracingStatus::Needed();
 
   if (IsStackAllocated())
     return TracingStatus::Unneeded();
 
   for (Bases::iterator it = GetBases().begin(); it != GetBases().end(); ++it) {
     if (it->second.info()->NeedsTracing(option).IsNeeded())
       return TracingStatus::Needed();
@@ skipping 76 matching lines @@
         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);
 }