reflow comments in platform/heap

third_party/WebKit/Source/platform/heap/ThreadState.h

 /*
  * 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 61 matching lines @@
 // that may be collected in the same GC cycle. If you cannot avoid touching
 // on-heap objects in a destructor (which is not allowed), you can consider
 // using the pre-finalizer. The only restriction is that the pre-finalizer
 // must not resurrect dead objects (e.g., store unmarked objects into
 // Members etc). The pre-finalizer is called on the thread that registered
 // the pre-finalizer.
 //
 // Since a pre-finalizer adds pressure on GC performance, you should use it
 // only if necessary.
 //
-// A pre-finalizer is similar to the HeapHashMap<WeakMember<Foo>, std::unique_ptr<Disposer>>
-// idiom.  The difference between this and the idiom is that pre-finalizer
-// function is called whenever an object is destructed with this feature.  The
-// HeapHashMap<WeakMember<Foo>, std::unique_ptr<Disposer>> idiom requires an assumption
-// that the HeapHashMap outlives objects pointed by WeakMembers.
-// FIXME: Replace all of the HeapHashMap<WeakMember<Foo>, std::unique_ptr<Disposer>>
-// idiom usages with the pre-finalizer if the replacement won't cause
-// performance regressions.
+// A pre-finalizer is similar to the
+// HeapHashMap<WeakMember<Foo>, std::unique_ptr<Disposer>> idiom.  The
+// difference between this and the idiom is that pre-finalizer function is
+// called whenever an object is destructed with this feature.  The
+// HeapHashMap<WeakMember<Foo>, std::unique_ptr<Disposer>> idiom requires an
+// assumption that the HeapHashMap outlives objects pointed by WeakMembers.
+// FIXME: Replace all of the
+// HeapHashMap<WeakMember<Foo>, std::unique_ptr<Disposer>> idiom usages with the
+// pre-finalizer if the replacement won't cause performance regressions.
 //
 // Usage:
 //
 // class Foo : GarbageCollected<Foo> {
 //     USING_PRE_FINALIZER(Foo, dispose);
 // public:
 //     Foo()
 //     {
 //         ThreadState::current()->registerPreFinalizer(this);
 //     }
@@ skipping 211 matching lines @@
   // We say that a thread is at a safepoint if this thread is guaranteed to
   // not touch any heap allocated object or any heap related functionality until
   // it leaves the safepoint.
   //
   // Notice that a thread does not have to be paused if it is at safepoint it
   // can continue to run and perform tasks that do not require interaction
   // with the heap. It will be paused if it attempts to leave the safepoint and
   // there is a GC in progress.
   //
   // Each thread that has ThreadState attached must:
-  //   - periodically check if GC is requested from another thread by calling a safePoint() method;
-  //   - use SafePointScope around long running loops that have no safePoint() invocation inside,
-  //     such loops must not touch any heap object;
-  //   - register an BlinkGCInterruptor that can interrupt long running loops that have no calls to safePoint and
-  //     are not wrapped in a SafePointScope (e.g. BlinkGCInterruptor for JavaScript code)
+  //   - periodically check if GC is requested from another thread by calling a
+  //     safePoint() method;
+  //   - use SafePointScope around long running loops that have no safePoint()
+  //     invocation inside, such loops must not touch any heap object;
+  //   - register an BlinkGCInterruptor that can interrupt long running loops
+  //     that have no calls to safePoint and are not wrapped in a SafePointScope
+  //     (e.g. BlinkGCInterruptor for JavaScript code)
   //
 
-  // Check if GC is requested by another thread and pause this thread if this is the case.
-  // Can only be called when current thread is in a consistent state.
+  // Check if GC is requested by another thread and pause this thread if this is
+  // the case.  Can only be called when current thread is in a consistent state.
   void safePoint(BlinkGC::StackState);
 
   // Mark current thread as running inside safepoint.
   void enterSafePoint(BlinkGC::StackState, void*);
   void leaveSafePoint(SafePointAwareMutexLocker* = nullptr);
   bool isAtSafePoint() const { return m_atSafePoint; }
 
   void addInterruptor(std::unique_ptr<BlinkGCInterruptor>);
 
   void recordStackEnd(intptr_t* endOfStack) { m_endOfStack = endOfStack; }
@@ skipping 111 matching lines @@
   }
   void leaveGCForbiddenScopeIfNeeded(
       GarbageCollectedMixinConstructorMarker* gcMixinMarker) {
     ASSERT(checkThread());
     if (m_gcMixinMarker == gcMixinMarker) {
       leaveGCForbiddenScope();
       m_gcMixinMarker = nullptr;
     }
   }
 
-  // vectorBackingArena() returns an arena that the vector allocation should use.
-  // We have four vector arenas and want to choose the best arena here.
+  // vectorBackingArena() returns an arena that the vector allocation should
+  // use.  We have four vector arenas and want to choose the best arena here.
   //
   // The goal is to improve the succession rate where expand and
   // promptlyFree happen at an allocation point. This is a key for reusing
   // the same memory as much as possible and thus improves performance.
   // To achieve the goal, we use the following heuristics:
   //
   // - A vector that has been expanded recently is likely to be expanded
   //   again soon.
   // - A vector is likely to be promptly freed if the same type of vector
   //   has been frequently promptly freed in the past.
@@ skipping 74 matching lines @@
   explicit ThreadState(BlinkGC::ThreadHeapMode);
   ~ThreadState();
 
   NO_SANITIZE_ADDRESS void copyStackUntilSafePointScope();
   void clearSafePointScopeMarker() {
     m_safePointStackCopy.clear();
     m_safePointScopeMarker = nullptr;
   }
 
   // shouldSchedule{Precise,Idle}GC and shouldForceConservativeGC
-  // implement the heuristics that are used to determine when to collect garbage.
+  // implement the heuristics that are used to determine when to collect
+  // garbage.
   // If shouldForceConservativeGC returns true, we force the garbage
   // collection immediately. Otherwise, if should*GC returns true, we
   // record that we should garbage collect the next time we return
   // to the event loop. If both return false, we don't need to
   // collect garbage at this point.
   bool shouldScheduleIdleGC();
   bool shouldSchedulePreciseGC();
   bool shouldForceConservativeGC();
   // V8 minor or major GC is likely to drop a lot of references to objects
   // on Oilpan's heap. We give a chance to schedule a GC.
@@ skipping 158 matching lines @@
 class ThreadStateFor<AnyThread> {
   STATIC_ONLY(ThreadStateFor);
 
  public:
   static ThreadState* state() { return ThreadState::current(); }
 };
 
 }  // namespace blink
 
 #endif  // ThreadState_h