heap: Move virtual methods to cc file

- Virtual Visit methods are always called through base class Visitor
  using Trace methods. There's no need to keep them in the header file.
- Drive-by: Move inlined definitions out-of-line to allow skimming the
  class header more easily.
- Only mark definition as inline as this is an implementation detail.

Change-Id: I44993d515eb18498105b0e592e282fcd536c82ff
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1884731Reviewed-by: Anton Bikineev <bikineev@chromium.org>
Commit-Queue: Michael Lippautz <mlippautz@chromium.org>
Cr-Commit-Position: refs/heads/master@{#710688}

third_party/blink/renderer/platform/heap/marking_visitor.cc

@@ -65,6 +65,57 @@ void MarkingVisitorCommon::RegisterBackingStoreCallback(
   }
 }
 
+void MarkingVisitorCommon::VisitWeak(void* object,
+                                     void* object_weak_ref,
+                                     TraceDescriptor desc,
+                                     WeakCallback callback) {
+  // Filter out already marked values. The write barrier for WeakMember
+  // ensures that any newly set value after this point is kept alive and does
+  // not require the callback.
+  if (desc.base_object_payload != BlinkGC::kNotFullyConstructedObject &&
+      HeapObjectHeader::FromPayload(desc.base_object_payload)
+          ->IsMarked<HeapObjectHeader::AccessMode::kAtomic>())
+    return;
+  RegisterWeakCallback(object_weak_ref, callback);
+}
+
+void MarkingVisitorCommon::VisitBackingStoreStrongly(void* object,
+                                                     void** object_slot,
+                                                     TraceDescriptor desc) {
+  RegisterBackingStoreReference(object_slot);
+  if (!object)
+    return;
+  Visit(object, desc);
+}
+
+// All work is registered through RegisterWeakCallback.
+void MarkingVisitorCommon::VisitBackingStoreWeakly(void* object,
+                                                   void** object_slot,
+                                                   TraceDescriptor strong_desc,
+                                                   TraceDescriptor weak_desc,
+                                                   WeakCallback callback,
+                                                   void* parameter) {
+  RegisterBackingStoreReference(object_slot);
+  if (!object)
+    return;
+  RegisterWeakCallback(parameter, callback);
+
+  if (weak_desc.callback) {
+    weak_table_worklist_.Push(
+        {weak_desc.base_object_payload, weak_desc.callback});
+  }
+}
+
+void MarkingVisitorCommon::VisitBackingStoreOnly(void* object,
+                                                 void** object_slot) {
+  RegisterBackingStoreReference(object_slot);
+  if (!object)
+    return;
+  HeapObjectHeader* header = HeapObjectHeader::FromPayload(object);
+  MarkHeaderNoTracing(header);
+  AccountMarkedBytes(header);
+}
+
 // static
 bool MarkingVisitor::WriteBarrierSlow(void* value) {
   if (!value || IsHashTableDeleteValue(value))

third_party/blink/renderer/platform/heap/unified_heap_marking_visitor.cc

@@ -52,6 +52,7 @@ UnifiedHeapMarkingVisitor::UnifiedHeapMarkingVisitor(ThreadState* thread_state,
                                     isolate,
                                     WorklistTaskId::MutatorThread) {}
 
+// static
 void UnifiedHeapMarkingVisitor::WriteBarrier(
     const TraceWrapperV8Reference<v8::Value>& object) {
   if (object.IsEmpty() || !ThreadState::IsAnyIncrementalMarking())
@@ -64,6 +65,7 @@ void UnifiedHeapMarkingVisitor::WriteBarrier(
   thread_state->CurrentVisitor()->Trace(object);
 }
 
+// static
 void UnifiedHeapMarkingVisitor::WriteBarrier(
     v8::Isolate* isolate,
     const WrapperTypeInfo* wrapper_type_info,
@@ -80,6 +82,11 @@ void UnifiedHeapMarkingVisitor::WriteBarrier(
   wrapper_type_info->Trace(thread_state->CurrentVisitor(), object);
 }
 
+void UnifiedHeapMarkingVisitor::Visit(
+    const TraceWrapperV8Reference<v8::Value>& v) {
+  VisitImpl(v);
+}
+
 ConcurrentUnifiedHeapMarkingVisitor::ConcurrentUnifiedHeapMarkingVisitor(
     ThreadState* thread_state,
     MarkingMode mode,
@@ -93,4 +100,9 @@ void ConcurrentUnifiedHeapMarkingVisitor::FlushWorklists() {
   v8_references_worklist_.FlushToGlobal();
 }
 
+void ConcurrentUnifiedHeapMarkingVisitor::Visit(
+    const TraceWrapperV8Reference<v8::Value>& v) {
+  VisitImpl(v);
+}
+
 }  // namespace blink

third_party/blink/renderer/platform/heap/unified_heap_marking_visitor.h

@@ -47,16 +47,14 @@ class PLATFORM_EXPORT UnifiedHeapMarkingVisitor
     : public MarkingVisitor,
       public UnifiedHeapMarkingVisitorBase {
  public:
-  UnifiedHeapMarkingVisitor(ThreadState*, MarkingMode, v8::Isolate*);
-  ~UnifiedHeapMarkingVisitor() override = default;
-
   // Write barriers for annotating a write during incremental marking.
   static void WriteBarrier(const TraceWrapperV8Reference<v8::Value>&);
   static void WriteBarrier(v8::Isolate*, const WrapperTypeInfo*, void*);
 
-  void Visit(const TraceWrapperV8Reference<v8::Value>& v) final {
-    VisitImpl(v);
-  }
+  UnifiedHeapMarkingVisitor(ThreadState*, MarkingMode, v8::Isolate*);
+  ~UnifiedHeapMarkingVisitor() override = default;
+
+  void Visit(const TraceWrapperV8Reference<v8::Value>&) final;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(UnifiedHeapMarkingVisitor);
@@ -74,9 +72,7 @@ class PLATFORM_EXPORT ConcurrentUnifiedHeapMarkingVisitor
                                       int task_id);
   ~ConcurrentUnifiedHeapMarkingVisitor() override = default;
 
-  void Visit(const TraceWrapperV8Reference<v8::Value>& v) final {
-    VisitImpl(v);
-  }
+  void Visit(const TraceWrapperV8Reference<v8::Value>&) final;
 
   void FlushWorklists() override;