reflow comments in platform/{testing,text}

third_party/WebKit/Source/platform/testing/ImageDecodeBench.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Provides a minimal wrapping of the Blink image decoders. Used to perform
 // a non-threaded, memory-to-memory image decode using micro second accuracy
 // clocks to measure image decode time. Optionally applies color correction
 // during image decoding on supported platforms (default off). Usage:
 //
 //   % ninja -C out/Release image_decode_bench &&
@@ skipping 23 matching lines @@
 #else
 #include <sys/stat.h>
 #include <sys/time.h>
 typedef struct stat sttype;
 #endif
 
 using namespace blink;
 
 #if defined(_WIN32)
 
-// There is no real platform support herein, so adopt the WIN32 performance counter from
-// WTF http://trac.webkit.org/browser/trunk/Source/WTF/wtf/CurrentTime.cpp?rev=152438
+// There is no real platform support herein, so adopt the WIN32 performance
+// counter from WTF
+// http://trac.webkit.org/browser/trunk/Source/WTF/wtf/CurrentTime.cpp?rev=152438
 
 static double lowResUTCTime() {
   FILETIME fileTime;
   GetSystemTimeAsFileTime(&fileTime);
 
-  // As per Windows documentation for FILETIME, copy the resulting FILETIME structure to a
-  // ULARGE_INTEGER structure using memcpy (using memcpy instead of direct assignment can
-  // prevent alignment faults on 64-bit Windows).
+  // As per Windows documentation for FILETIME, copy the resulting FILETIME
+  // structure to a ULARGE_INTEGER structure using memcpy (using memcpy instead
+  // of direct assignment can prevent alignment faults on 64-bit Windows).
   ULARGE_INTEGER dateTime;
   memcpy(&dateTime, &fileTime, sizeof(dateTime));
 
   // Number of 100 nanosecond between January 1, 1601 and January 1, 1970.
   static const ULONGLONG epochBias = 116444736000000000ULL;
   // Windows file times are in 100s of nanoseconds.
   static const double hundredsOfNanosecondsPerMillisecond = 10000;
   return (dateTime.QuadPart - epochBias) / hundredsOfNanosecondsPerMillisecond;
 }
 
 static LARGE_INTEGER qpcFrequency;
 static bool syncedTime;
 
 static double highResUpTime() {
   // We use QPC, but only after sanity checking its result, due to bugs:
-  // http://support.microsoft.com/kb/274323 http://support.microsoft.com/kb/895980
-  // http://msdn.microsoft.com/en-us/library/ms644904.aspx ("you can get different results
-  // on different processors due to bugs in the basic input/output system (BIOS) or the
-  // hardware abstraction layer (HAL).").
+  // http://support.microsoft.com/kb/274323
+  // http://support.microsoft.com/kb/895980
+  // http://msdn.microsoft.com/en-us/library/ms644904.aspx ("you can get
+  // different results on different processors due to bugs in the basic
+  // input/output system (BIOS) or the hardware abstraction layer (HAL).").
 
   static LARGE_INTEGER qpcLast;
   static DWORD tickCountLast;
   static bool inited;
 
   LARGE_INTEGER qpc;
   QueryPerformanceCounter(&qpc);
   DWORD tickCount = GetTickCount();
 
   if (inited) {
     __int64 qpcElapsed =
         ((qpc.QuadPart - qpcLast.QuadPart) * 1000) / qpcFrequency.QuadPart;
     __int64 tickCountElapsed;
     if (tickCount >= tickCountLast) {
       tickCountElapsed = (tickCount - tickCountLast);
     } else {
       __int64 tickCountLarge = tickCount + 0x100000000I64;
       tickCountElapsed = tickCountLarge - tickCountLast;
     }
 
-    // Force a re-sync if QueryPerformanceCounter differs from GetTickCount() by more than
-    // 500ms. (The 500ms value is from http://support.microsoft.com/kb/274323).
+    // Force a re-sync if QueryPerformanceCounter differs from GetTickCount() by
+    // more than 500ms. (The 500ms value is from
+    // http://support.microsoft.com/kb/274323).
     __int64 diff = tickCountElapsed - qpcElapsed;
     if (diff > 500 || diff < -500)
       syncedTime = false;
   } else {
     inited = true;
   }
 
   qpcLast = qpc;
   tickCountLast = tickCount;
 
   return (1000.0 * qpc.QuadPart) / static_cast<double>(qpcFrequency.QuadPart);
 }
 
 static bool qpcAvailable() {
   static bool available;
   static bool checked;
 
   if (checked)
     return available;
 
   available = QueryPerformanceFrequency(&qpcFrequency);
   checked = true;
   return available;
 }
 
 static double getCurrentTime() {
   // Use a combination of ftime and QueryPerformanceCounter.
-  // ftime returns the information we want, but doesn't have sufficient resolution.
-  // QueryPerformanceCounter has high resolution, but is only usable to measure time intervals.
-  // To combine them, we call ftime and QueryPerformanceCounter initially. Later calls will
-  // use QueryPerformanceCounter by itself, adding the delta to the saved ftime.
-  // We periodically re-sync to correct for drift.
+  // ftime returns the information we want, but doesn't have sufficient
+  // resolution.  QueryPerformanceCounter has high resolution, but is only
+  // usable to measure time intervals.  To combine them, we call ftime and
+  // QueryPerformanceCounter initially. Later calls will use
+  // QueryPerformanceCounter by itself, adding the delta to the saved ftime.  We
+  // periodically re-sync to correct for drift.
   static double syncLowResUTCTime;
   static double syncHighResUpTime;
   static double lastUTCTime;
 
   double lowResTime = lowResUTCTime();
   if (!qpcAvailable())
     return lowResTime * (1.0 / 1000.0);
 
   double highResTime = highResUpTime();
   if (!syncedTime) {
     timeBeginPeriod(1);  // increase time resolution around low-res time getter
     syncLowResUTCTime = lowResTime = lowResUTCTime();
     timeEndPeriod(1);  // restore time resolution
     syncHighResUpTime = highResTime;
     syncedTime = true;
   }
 
   double highResElapsed = highResTime - syncHighResUpTime;
   double utc = syncLowResUTCTime + highResElapsed;
 
   // Force a clock re-sync if we've drifted.
   double lowResElapsed = lowResTime - syncLowResUTCTime;
   const double maximumAllowedDriftMsec =
       15.625 * 2.0;  // 2x the typical low-res accuracy
   if (fabs(highResElapsed - lowResElapsed) > maximumAllowedDriftMsec)
     syncedTime = false;
 
-  // Make sure time doesn't run backwards (only correct if the difference is < 2 seconds,
-  // since DST or clock changes could occur).
+  // Make sure time doesn't run backwards (only correct if the difference is < 2
+  // seconds, since DST or clock changes could occur).
   const double backwardTimeLimit = 2000.0;
   if (utc < lastUTCTime && (lastUTCTime - utc) < backwardTimeLimit)
     return lastUTCTime * (1.0 / 1000.0);
 
   lastUTCTime = utc;
   return utc * (1.0 / 1000.0);
 }
 
 #else
 
@@ skipping 229 matching lines @@
       exit(3);
     }
   }
 
   // Results to stdout.
 
   double averageTime = totalTime / static_cast<double>(iterations);
   printf("%f %f\n", totalTime, averageTime);
   return 0;
 }