reflow comments in core/{clipboard,streams,testing,timing}

third_party/WebKit/Source/core/timing/MemoryInfo.cpp

 /*
  * Copyright (C) 2010 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 56 matching lines @@
 
   static HeapSizeCache& forCurrentThread() {
     DEFINE_THREAD_SAFE_STATIC_LOCAL(ThreadSpecific<HeapSizeCache>,
                                     heapSizeCache,
                                     new ThreadSpecific<HeapSizeCache>);
     return *heapSizeCache;
   }
 
  private:
   void maybeUpdate() {
-    // We rate-limit queries to once every twenty minutes to make it more difficult
-    // for attackers to compare memory usage before and after some event.
+    // We rate-limit queries to once every twenty minutes to make it more
+    // difficult for attackers to compare memory usage before and after some
+    // event.
     double now = monotonicallyIncreasingTime();
     if (now - m_lastUpdateTime >= TwentyMinutesInSeconds) {
       update();
       m_lastUpdateTime = now;
     }
   }
 
   void update() {
     getHeapSize(m_info);
     m_info.usedJSHeapSize = quantizeMemorySize(m_info.usedJSHeapSize);
     m_info.totalJSHeapSize = quantizeMemorySize(m_info.totalJSHeapSize);
     m_info.jsHeapSizeLimit = quantizeMemorySize(m_info.jsHeapSizeLimit);
   }
 
   double m_lastUpdateTime;
 
   HeapInfo m_info;
 };
 
-// We quantize the sizes to make it more difficult for an attacker to see precise
-// impact of operations on memory. The values are used for performance tuning,
-// and hence don't need to be as refined when the value is large, so we threshold
-// at a list of exponentially separated buckets.
+// We quantize the sizes to make it more difficult for an attacker to see
+// precise impact of operations on memory. The values are used for performance
+// tuning, and hence don't need to be as refined when the value is large, so we
+// threshold at a list of exponentially separated buckets.
 size_t quantizeMemorySize(size_t size) {
   const int numberOfBuckets = 100;
   DEFINE_STATIC_LOCAL(Vector<size_t>, bucketSizeList, ());
 
   if (bucketSizeList.isEmpty()) {
     bucketSizeList.resize(numberOfBuckets);
 
     float sizeOfNextBucket = 10000000.0;  // First bucket size is roughly 10M.
     const float largestBucketSize = 4000000000.0;  // Roughly 4GB.
     // We scale with the Nth root of the ratio, so that we use all the bucktes.
@@ skipping 33 matching lines @@
 }
 
 MemoryInfo::MemoryInfo() {
   if (RuntimeEnabledFeatures::preciseMemoryInfoEnabled())
     getHeapSize(m_info);
   else
     HeapSizeCache::forCurrentThread().getCachedHeapSize(m_info);
 }
 
 }  // namespace blink