Create retainment infos from handles, even for tracing

third_party/WebKit/Source/bindings/core/v8/V8GCController.cpp

 /*
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 133 matching lines @@
     }
   }
 
  private:
   v8::Isolate* m_isolate;
 };
 
 class MajorGCWrapperVisitor : public v8::PersistentHandleVisitor {
  public:
   explicit MajorGCWrapperVisitor(v8::Isolate* isolate,
-                                 bool constructRetainedObjectInfos)
+                                 bool constructRetainedObjectInfos,
+                                 bool constructImplicitReferenceGroups)
       : m_isolate(isolate),
         m_domObjectsWithPendingActivity(0),
         m_liveRootGroupIdSet(false),
-        m_constructRetainedObjectInfos(constructRetainedObjectInfos) {}
+        m_constructRetainedObjectInfos(constructRetainedObjectInfos),
+        m_constructImplicitReferenceGroups(constructImplicitReferenceGroups) {
+    DCHECK(m_constructRetainedObjectInfos ||
+           m_constructImplicitReferenceGroups);
+  }
 
   void VisitPersistentHandle(v8::Persistent<v8::Value>* value,
                              uint16_t classId) override {
     if (classId != WrapperTypeInfo::NodeClassId &&
         classId != WrapperTypeInfo::ObjectClassId)
       return;
 
     if (value->IsIndependent())
       return;
 
@@ skipping 17 matching lines @@
           toExecutionContext(wrapper->CreationContext());
       if (context && !context->activeDOMObjectsAreStopped()) {
         m_isolate->SetObjectGroupId(*value, liveRootId());
         ++m_domObjectsWithPendingActivity;
       }
     }
 
     if (classId == WrapperTypeInfo::NodeClassId) {
       DCHECK(V8Node::hasInstance(wrapper, m_isolate));
       Node* node = V8Node::toImpl(wrapper);
       if (node->hasEventListeners())

[Michael Lippautz, 2016/10/04 10:42:51]

This branch should also be guarded with m_constructImplicitReferenceGroups.

Then the part of the test at
https://cs.chromium.org/chromium/src/third_party/WebKit/LayoutTests/inspector...
would need to be ripped out since we are not retained by HTMLBodyElement
anymore.

wdyt?

(If we decide to also guard it and change the test I can rewrite this branches
in a nicer way.)

[Michael Lippautz, 2016/10/04 11:02:36]

Sorry for the confusion but if we want to stay compatible this should not be
guarded (althouh it creates an implicit ref group) as we also create retainer
infos for it (line 207+208).

         addReferencesForNodeWithEventListeners(
             m_isolate, node, v8::Persistent<v8::Object>::Cast(*value));
       Node* root = V8GCController::opaqueRootForGC(m_isolate, node);
       m_isolate->SetObjectGroupId(
           *value, v8::UniqueId(reinterpret_cast<intptr_t>(root)));
       if (m_constructRetainedObjectInfos)
         m_groupsWhichNeedRetainerInfo.append(root);
     } else if (classId == WrapperTypeInfo::ObjectClassId) {
-      type->visitDOMWrapper(m_isolate, toScriptWrappable(wrapper),
-                            v8::Persistent<v8::Object>::Cast(*value));
+      if (m_constructImplicitReferenceGroups) {

[haraken, 2016/10/04 11:24:48]

I'd directly use !RuntimeEnabledFeatures::traceWrappablesEnabled() and avoid
introducing an indirection variable like m_constructImplicitReferenceGroups.

[Michael Lippautz, 2016/10/04 11:31:02]

Done.

+        type->visitDOMWrapper(m_isolate, toScriptWrappable(wrapper),
+                              v8::Persistent<v8::Object>::Cast(*value));
+      }
     } else {
       NOTREACHED();
     }
   }
 
   void notifyFinished() {
     if (!m_constructRetainedObjectInfos)
       return;
     std::sort(m_groupsWhichNeedRetainerInfo.begin(),
               m_groupsWhichNeedRetainerInfo.end());
@@ skipping 29 matching lines @@
   }
 
   v8::Isolate* m_isolate;
   // v8 guarantees that Blink will not regain control while a v8 GC runs
   // (=> no Oilpan GCs will be triggered), hence raw, untraced members
   // can safely be kept here.
   Vector<UntracedMember<Node>> m_groupsWhichNeedRetainerInfo;
   int m_domObjectsWithPendingActivity;
   bool m_liveRootGroupIdSet;
   bool m_constructRetainedObjectInfos;
+  bool m_constructImplicitReferenceGroups;
 };
 
 static unsigned long long usedHeapSize(v8::Isolate* isolate) {
   v8::HeapStatistics heapStatistics;
   isolate->GetHeapStatistics(&heapStatistics);
   return heapStatistics.used_heap_size();
 }
 
 namespace {
 
 void visitWeakHandlesForMinorGC(v8::Isolate* isolate) {
   MinorGCUnmodifiedWrapperVisitor visitor(isolate);
   isolate->VisitWeakHandles(&visitor);
 }
 
 void objectGroupingForMajorGC(v8::Isolate* isolate,
-                              bool constructRetainedObjectInfos) {
-  MajorGCWrapperVisitor visitor(isolate, constructRetainedObjectInfos);
+                              bool constructRetainedObjectInfos,
+                              bool constructImplicitReferenceGroups) {

[haraken, 2016/10/04 11:24:48]

constructImplicitReferenceGroups is unused.

[Michael Lippautz, 2016/10/04 11:31:02]

Done.

+  MajorGCWrapperVisitor visitor(
+      isolate, constructRetainedObjectInfos,
+      !RuntimeEnabledFeatures::traceWrappablesEnabled());
   isolate->VisitHandlesWithClassIds(&visitor);
   visitor.notifyFinished();
 }
 
 void gcPrologueForMajorGC(v8::Isolate* isolate,
                           bool constructRetainedObjectInfos) {
-  // TODO(hlopko): Collect retained object infos for heap profiler
-  if (!RuntimeEnabledFeatures::traceWrappablesEnabled()) {
-    objectGroupingForMajorGC(isolate, constructRetainedObjectInfos);
+  const bool objectGrouping = !RuntimeEnabledFeatures::traceWrappablesEnabled();
+  if (objectGrouping || constructRetainedObjectInfos) {
+    objectGroupingForMajorGC(isolate, constructRetainedObjectInfos,
+                             objectGrouping);
   }
 }
 
 }  // namespace
 
 void V8GCController::gcPrologue(v8::Isolate* isolate,
                                 v8::GCType type,
                                 v8::GCCallbackFlags flags) {
   if (isMainThread())
     ScriptForbiddenScope::enter();
@@ skipping 244 matching lines @@
   double startTime = WTF::currentTimeMS();
   v8::HandleScope scope(isolate);
   PendingActivityVisitor visitor(isolate, executionContext);
   toIsolate(executionContext)->VisitHandlesWithClassIds(&visitor);
   scanPendingActivityHistogram.count(
       static_cast<int>(WTF::currentTimeMS() - startTime));
   return visitor.pendingActivityFound();
 }
 
 }  // namespace blink