reflow comments in platform/heap

third_party/WebKit/Source/platform/heap/HeapTest.cpp

 /*
  * Copyright (C) 2013 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 120 matching lines @@
 
 typedef std::pair<Member<IntWrapper>, WeakMember<IntWrapper>> StrongWeakPair;
 
 struct PairWithWeakHandling : public StrongWeakPair {
   DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
 
  public:
   // Regular constructor.
   PairWithWeakHandling(IntWrapper* one, IntWrapper* two)
       : StrongWeakPair(one, two) {
-    ASSERT(
-        one);  // We use null first field to indicate empty slots in the hash table.
+    ASSERT(one);  // We use null first field to indicate empty slots in the hash
+                  // table.
   }
 
   // The HashTable (via the HashTrait) calls this constructor with a
   // placement new to mark slots in the hash table as being deleted. We will
-  // never call trace or the destructor on these slots. We mark ourselves deleted
+  // never call trace or the destructor on these slots. We mark ourselves
+  // deleted
   // with a pointer to -1 in the first field.
   PairWithWeakHandling(WTF::HashTableDeletedValueType)
       : StrongWeakPair(reinterpret_cast<IntWrapper*>(-1), nullptr) {}
 
   // Used by the HashTable (via the HashTrait) to skip deleted slots in the
   // table. Recognizes objects that were 'constructed' using the above
   // constructor.
   bool isHashTableDeletedValue() const {
     return first == reinterpret_cast<IntWrapper*>(-1);
   }
 
   // Since we don't allocate independent objects of this type, we don't need
   // a regular trace method. Instead, we use a traceInCollection method. If
   // the entry should be deleted from the collection we return true and don't
   // trace the strong pointer.
   template <typename VisitorDispatcher>
   bool traceInCollection(VisitorDispatcher visitor,
                          WTF::ShouldWeakPointersBeMarkedStrongly strongify) {
     visitor->traceInCollection(second, strongify);
     if (!ThreadHeap::isHeapObjectAlive(second))
       return true;
-    // FIXME: traceInCollection is also called from WeakProcessing to check if the entry is dead.
-    // The below if avoids calling trace in that case by only calling trace when |first| is not yet marked.
+    // FIXME: traceInCollection is also called from WeakProcessing to check if
+    // the entry is dead.
+    // The below if avoids calling trace in that case by only calling trace when
+    // |first| is not yet marked.
     if (!ThreadHeap::isHeapObjectAlive(first))
       visitor->trace(first);
     return false;
   }
 };
 
 template <typename T>
 struct WeakHandlingHashTraits : WTF::SimpleClassHashTraits<T> {
   // We want to treat the object as a weak object in the sense that it can
   // disappear from hash sets and hash maps.
@@ skipping 398 matching lines @@
 
         if (gcCount < gcPerThread) {
           preciselyCollectGarbage();
           gcCount++;
           atomicIncrement(&m_gcCount);
         }
 
         // Taking snapshot shouldn't have any bad side effect.
         // TODO(haraken): This snapshot GC causes crashes, so disable
         // it at the moment. Fix the crash and enable it.
-        // ThreadHeap::collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::TakeSnapshot, BlinkGC::ForcedGC);
+        // ThreadHeap::collectGarbage(BlinkGC::NoHeapPointersOnStack,
+        //                            BlinkGC::TakeSnapshot, BlinkGC::ForcedGC);
         preciselyCollectGarbage();
         EXPECT_EQ(wrapper->value(), 0x0bbac0de);
         EXPECT_EQ((*globalPersistent)->value(), 0x0ed0cabb);
       }
       SafePointScope scope(BlinkGC::NoHeapPointersOnStack);
       testing::yieldCurrentThread();
     }
 
     ThreadState::detachCurrentThread();
     atomicDecrement(&m_threadsToFinish);
@@ skipping 25 matching lines @@
 
         if (gcCount < gcPerThread) {
           preciselyCollectGarbage();
           gcCount++;
           atomicIncrement(&m_gcCount);
         }
 
         // Taking snapshot shouldn't have any bad side effect.
         // TODO(haraken): This snapshot GC causes crashes, so disable
         // it at the moment. Fix the crash and enable it.
-        // ThreadHeap::collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::TakeSnapshot, BlinkGC::ForcedGC);
+        // ThreadHeap::collectGarbage(BlinkGC::NoHeapPointersOnStack,
+        //                            BlinkGC::TakeSnapshot, BlinkGC::ForcedGC);
         preciselyCollectGarbage();
         EXPECT_TRUE(weakMap->isEmpty());
         EXPECT_TRUE(weakMap2.isEmpty());
       }
       SafePointScope scope(BlinkGC::NoHeapPointersOnStack);
       testing::yieldCurrentThread();
     }
     ThreadState::detachCurrentThread();
     atomicDecrement(&m_threadsToFinish);
   }
@@ skipping 1002 matching lines @@
   {
     size_t slack = 0;
 
     // When the test starts there may already have been leaked some memory
     // on the heap, so we establish a base line.
     size_t baseLevel = initialObjectPayloadSize;
     bool testPagesAllocated = !baseLevel;
     if (testPagesAllocated)
       EXPECT_EQ(heap.heapStats().allocatedSpace(), 0ul);
 
-    // This allocates objects on the general heap which should add a page of memory.
+    // This allocates objects on the general heap which should add a page of
+    // memory.
     DynamicallySizedObject* alloc32 = DynamicallySizedObject::create(32);
     slack += 4;
     memset(alloc32, 40, 32);
     DynamicallySizedObject* alloc64 = DynamicallySizedObject::create(64);
     slack += 4;
     memset(alloc64, 27, 64);
 
     size_t total = 96;
 
     CheckWithSlack(baseLevel + total, heap.objectPayloadSizeForTesting(),
@@ skipping 2268 matching lines @@
   // This is a low-level test where we call checkAndMarkPointer. This method
   // causes the object start bitmap to be computed which requires the heap
   // to be in a consistent state (e.g. the free allocation area must be put
   // into a free list header). However when we call makeConsistentForGC it
   // also clears out the freelists so we have to rebuild those before trying
   // to allocate anything again. We do this by forcing a GC after doing the
   // checkAndMarkPointer tests.
   {
     TestGCScope scope(BlinkGC::HeapPointersOnStack);
     CountingVisitor visitor(ThreadState::current());
-    EXPECT_TRUE(
-        scope
-            .allThreadsParked());  // Fail the test if we could not park all threads.
+    EXPECT_TRUE(scope.allThreadsParked());  // Fail the test if we could not
+                                            // park all threads.
     heap.flushHeapDoesNotContainCache();
     for (size_t i = 0; i < objectAddresses.size(); i++) {
       EXPECT_TRUE(heap.checkAndMarkPointer(&visitor, objectAddresses[i]));
       EXPECT_TRUE(heap.checkAndMarkPointer(&visitor, endAddresses[i]));
     }
     EXPECT_EQ(objectAddresses.size() * 2, visitor.count());
     visitor.reset();
     EXPECT_TRUE(heap.checkAndMarkPointer(&visitor, largeObjectAddress));
     EXPECT_TRUE(heap.checkAndMarkPointer(&visitor, largeObjectEndAddress));
     EXPECT_EQ(2ul, visitor.count());
@@ skipping 924 matching lines @@
     // weak processing may have taken place.
     if (set3->size()) {
       Iterator i3 = set3->begin();
       EXPECT_EQ(2, i3->first->value());
       EXPECT_EQ(3, i3->second->value());
     }
   }
   preciselyCollectGarbage();
   EXPECT_EQ(0u, set1->size());
   set1->add(PairWithWeakHandling(IntWrapper::create(103), livingInt));
-  set1->add(PairWithWeakHandling(
-      livingInt,
-      IntWrapper::create(
-          103)));  // This one gets zapped at GC time because nothing holds the 103 alive.
+  // This one gets zapped at GC time because nothing holds the 103 alive.
+  set1->add(PairWithWeakHandling(livingInt, IntWrapper::create(103)));
   set1->add(PairWithWeakHandling(
       IntWrapper::create(103),
       IntWrapper::create(103)));  // This one gets zapped too.
   set1->add(PairWithWeakHandling(livingInt, livingInt));
-  set1->add(PairWithWeakHandling(
-      livingInt,
-      livingInt));  // This one is identical to the previous and doesn't add anything.
+  // This one is identical to the previous and doesn't add anything.
+  set1->add(PairWithWeakHandling(livingInt, livingInt));
   EXPECT_EQ(4u, set1->size());
   preciselyCollectGarbage();
   EXPECT_EQ(2u, set1->size());
   Iterator i1 = set1->begin();
   EXPECT_TRUE(i1->first->value() == 103 || i1->first == livingInt);
   EXPECT_EQ(livingInt, i1->second);
   ++i1;
   EXPECT_TRUE(i1->first->value() == 103 || i1->first == livingInt);
   EXPECT_EQ(livingInt, i1->second);
 }
@@ skipping 50 matching lines @@
   }
   preciselyCollectGarbage();
 
   EXPECT_EQ(0u, map1->size());
   EXPECT_EQ(3, OffHeapInt::s_destructorCalls);
 
   OffHeapInt::s_destructorCalls = 0;
 
   map1->add(PairWithWeakHandling(IntWrapper::create(103), livingInt),
             OffHeapInt::create(2000));
-  map1->add(
-      PairWithWeakHandling(livingInt, IntWrapper::create(103)),
-      OffHeapInt::create(
-          2001));  // This one gets zapped at GC time because nothing holds the 103 alive.
+  map1->add(PairWithWeakHandling(livingInt, IntWrapper::create(103)),
+            OffHeapInt::create(2001));  // This one gets zapped at GC time
+                                        // because nothing holds the 103 alive.
   map1->add(
       PairWithWeakHandling(IntWrapper::create(103), IntWrapper::create(103)),
       OffHeapInt::create(2002));  // This one gets zapped too.
   RefPtr<OffHeapInt> dupeInt(OffHeapInt::create(2003));
   map1->add(PairWithWeakHandling(livingInt, livingInt), dupeInt);
-  map1->add(
-      PairWithWeakHandling(livingInt, livingInt),
-      dupeInt);  // This one is identical to the previous and doesn't add anything.
+  map1->add(PairWithWeakHandling(livingInt, livingInt),
+            dupeInt);  // This one is identical to the previous and doesn't add
+                       // anything.
   dupeInt.clear();
 
   EXPECT_EQ(0, OffHeapInt::s_destructorCalls);
   EXPECT_EQ(4u, map1->size());
   preciselyCollectGarbage();
   EXPECT_EQ(2, OffHeapInt::s_destructorCalls);
   EXPECT_EQ(2u, map1->size());
   Iterator i1 = map1->begin();
   EXPECT_TRUE(i1->key.first->value() == 103 || i1->key.first == livingInt);
   EXPECT_EQ(livingInt, i1->key.second);
@@ skipping 51 matching lines @@
   }
   preciselyCollectGarbage();
 
   EXPECT_EQ(0u, map1->size());
   EXPECT_EQ(3, OffHeapInt::s_destructorCalls);
 
   OffHeapInt::s_destructorCalls = 0;
 
   map1->add(OffHeapInt::create(2000),
             PairWithWeakHandling(IntWrapper::create(103), livingInt));
-  map1->add(
-      OffHeapInt::create(2001),
-      PairWithWeakHandling(
-          livingInt,
-          IntWrapper::create(
-              103)));  // This one gets zapped at GC time because nothing holds the 103 alive.
+  // This one gets zapped at GC time because nothing holds the 103 alive.
+  map1->add(OffHeapInt::create(2001),
+            PairWithWeakHandling(livingInt, IntWrapper::create(103)));
   map1->add(OffHeapInt::create(2002),
             PairWithWeakHandling(
                 IntWrapper::create(103),
                 IntWrapper::create(103)));  // This one gets zapped too.
   RefPtr<OffHeapInt> dupeInt(OffHeapInt::create(2003));
   map1->add(dupeInt, PairWithWeakHandling(livingInt, livingInt));
-  map1->add(
-      dupeInt,
-      PairWithWeakHandling(
-          livingInt,
-          livingInt));  // This one is identical to the previous and doesn't add anything.
+  // This one is identical to the previous and doesn't add anything.
+  map1->add(dupeInt, PairWithWeakHandling(livingInt, livingInt));
   dupeInt.clear();
 
   EXPECT_EQ(0, OffHeapInt::s_destructorCalls);
   EXPECT_EQ(4u, map1->size());
   preciselyCollectGarbage();
   EXPECT_EQ(2, OffHeapInt::s_destructorCalls);
   EXPECT_EQ(2u, map1->size());
   Iterator i1 = map1->begin();
   EXPECT_TRUE(i1->value.first->value() == 103 || i1->value.first == livingInt);
   EXPECT_EQ(livingInt, i1->value.second);
@@ skipping 464 matching lines @@
       // until leaving the safepoint scope.
       SafePointScope scope(BlinkGC::NoHeapPointersOnStack);
       parkWorkerThread();
     }
 
     // Wake up the main thread when done sweeping.
     wakeMainThread();
 
     // Wait with detach until the main thread says so. This is not strictly
     // necessary, but it means the worker thread will not do its thread local
-    // GCs just yet, making it easier to reason about that no new GC has occurred
-    // and the above sweep was the one finalizing the worker object.
+    // GCs just yet, making it easier to reason about that no new GC has
+    // occurred and the above sweep was the one finalizing the worker object.
     parkWorkerThread();
 
     ThreadState::detachCurrentThread();
   }
 
   static volatile uintptr_t s_workerObjectPointer;
 };
 
 volatile uintptr_t DeadBitTester::s_workerObjectPointer = 0;
 
@@ skipping 809 matching lines @@
   }
 
   DEFINE_INLINE_VIRTUAL_TRACE() {}
 };
 
 class TestMixinAllocationB : public TestMixinAllocationA {
   USING_GARBAGE_COLLECTED_MIXIN(TestMixinAllocationB);
 
  public:
   TestMixinAllocationB()
-      : m_a(new TestMixinAllocationA())  // Construct object during a mixin construction.
+      : m_a(new TestMixinAllocationA())  // Construct object during a mixin
+                                         // construction.
   {
     // Completely wrong in general, but test only
     // runs this constructor while constructing another mixin.
     ASSERT(ThreadState::current()->isGCForbidden());
   }
 
   DEFINE_INLINE_TRACE() {
     visitor->trace(m_a);
     TestMixinAllocationA::trace(visitor);
   }
@@ skipping 112 matching lines @@
   parkWorkerThread();
 
   // Step 6: Finish.
   ThreadState::detachCurrentThread();
   wakeMainThread();
 }
 
 }  // anonymous namespace
 
 TEST(HeapTest, CrossThreadWeakPersistent) {
-  // Create an object in the worker thread, have a CrossThreadWeakPersistent pointing to it on the main thread,
-  // clear the reference in the worker thread, run a GC in the worker thread, and see if the
+  // Create an object in the worker thread, have a CrossThreadWeakPersistent
+  // pointing to it on the main thread, clear the reference in the worker
+  // thread, run a GC in the worker thread, and see if the
   // CrossThreadWeakPersistent is cleared.
 
   DestructorLockingObject::s_destructorCalls = 0;
 
-  // Step 1: Initiate a worker thread, and wait for |object| to get allocated on the worker thread.
+  // Step 1: Initiate a worker thread, and wait for |object| to get allocated on
+  // the worker thread.
   MutexLocker mainThreadMutexLocker(mainThreadMutex());
   std::unique_ptr<WebThread> workerThread =
       wrapUnique(Platform::current()->createThread("Test Worker Thread"));
   DestructorLockingObject* object = nullptr;
   workerThread->getWebTaskRunner()->postTask(
       BLINK_FROM_HERE,
       crossThreadBind(workerThreadMainForCrossThreadWeakPersistentTest,
                       crossThreadUnretained(&object)));
   parkMainThread();
 
@@ skipping 46 matching lines @@
   EXPECT_EQ(1u, vector2.size());
 // TODO(Oilpan): when Vector.h's contiguous container support no longer disables
 // Vector<>s with inline capacity, remove.
 #if !defined(ANNOTATE_CONTIGUOUS_CONTAINER)
   EXPECT_EQ(16u, vector1.capacity());
   EXPECT_EQ(16u, vector2.capacity());
 #endif
 }
 
 TEST(HeapTest, TestStaticLocals) {
-  // Sanity check DEFINE_STATIC_LOCAL()s over heap allocated objects and collections.
+  // Sanity check DEFINE_STATIC_LOCAL()s over heap allocated objects and
+  // collections.
 
   DEFINE_STATIC_LOCAL(IntWrapper, intWrapper, (new IntWrapper(33)));
   DEFINE_STATIC_LOCAL(PersistentHeapVector<Member<IntWrapper>>,
                       persistentHeapVectorIntWrapper, ());
   DEFINE_STATIC_LOCAL(HeapVector<Member<IntWrapper>>, heapVectorIntWrapper,
                       (new HeapVector<Member<IntWrapper>>));
 
   EXPECT_EQ(33, intWrapper.value());
   EXPECT_EQ(0u, persistentHeapVectorIntWrapper.size());
   EXPECT_EQ(0u, heapVectorIntWrapper.size());
@@ skipping 195 matching lines @@
       "HeapVector");
   static_assert(
       WTF::IsGarbageCollectedType<HeapDeque<Member<IntWrapper>>>::value,
       "HeapDeque");
   static_assert(WTF::IsGarbageCollectedType<
                     HeapTerminatedArray<Member<IntWrapper>>>::value,
                 "HeapTerminatedArray");
 }
 
 }  // namespace blink