Reflow comments in canvas-related folders

third_party/WebKit/Source/modules/canvas2d/CanvasRenderingContext2DTest.cpp

 // Copyright 2014 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.
 
 #include "modules/canvas2d/CanvasRenderingContext2D.h"
 
 #include "core/dom/Document.h"
 #include "core/fetch/MemoryCache.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/ImageBitmap.h"
@@ skipping 116 matching lines @@
 
     DEFINE_INLINE_TRACE() {
       visitor->trace(m_opaqueGradient);
       visitor->trace(m_alphaGradient);
     }
 
     StringOrCanvasGradientOrCanvasPattern m_opaqueGradient;
     StringOrCanvasGradientOrCanvasPattern m_alphaGradient;
   };
 
-  // TODO(Oilpan): avoid tedious part-object wrapper by supporting on-heap ::testing::Tests.
+  // TODO(Oilpan): avoid tedious part-object wrapper by supporting on-heap
+  // ::testing::Tests.
   Persistent<WrapGradients> m_wrapGradients;
 
  protected:
   // Pre-canned objects for testing
   Persistent<ImageData> m_fullImageData;
   Persistent<ImageData> m_partialImageData;
   FakeImageSource m_opaqueBitmap;
   FakeImageSource m_alphaBitmap;
 
   StringOrCanvasGradientOrCanvasPattern& opaqueGradient() {
@@ skipping 326 matching lines @@
   TEST_OVERDRAW_3(1, rect(0, 0, 5, 5), clip(),
                   putImageData(m_fullImageData.get(), 0, 0,
                                exceptionState));  // ignores clip
   EXPECT_FALSE(exceptionState.hadException());
 }
 
 TEST_F(CanvasRenderingContext2DTest, detectOverdrawWithCompositeOperations) {
   createContext(NonOpaque);
 
   // Test composite operators with an opaque rect that covers the entire canvas
-  // Note: all the untested composite operations take the same code path as source-in,
+  // Note: all the untested composite operations take the same code path as
+  // source-in,
   // which assumes that the destination may not be overwritten
   TEST_OVERDRAW_2(1, setGlobalCompositeOperation(String("clear")),
                   fillRect(0, 0, 10, 10));
   TEST_OVERDRAW_2(1, setGlobalCompositeOperation(String("copy")),
                   fillRect(0, 0, 10, 10));
   TEST_OVERDRAW_2(1, setGlobalCompositeOperation(String("source-over")),
                   fillRect(0, 0, 10, 10));
   TEST_OVERDRAW_2(0, setGlobalCompositeOperation(String("source-in")),
                   fillRect(0, 0, 10, 10));
-  // Test composite operators with a transparent rect that covers the entire canvas
+  // Test composite operators with a transparent rect that covers the entire
+  // canvas
   TEST_OVERDRAW_3(1, setGlobalAlpha(0.5f),
                   setGlobalCompositeOperation(String("clear")),
                   fillRect(0, 0, 10, 10));
   TEST_OVERDRAW_3(1, setGlobalAlpha(0.5f),
                   setGlobalCompositeOperation(String("copy")),
                   fillRect(0, 0, 10, 10));
   TEST_OVERDRAW_3(0, setGlobalAlpha(0.5f),
                   setGlobalCompositeOperation(String("source-over")),
                   fillRect(0, 0, 10, 10));
   TEST_OVERDRAW_3(0, setGlobalAlpha(0.5f),
                   setGlobalCompositeOperation(String("source-in")),
                   fillRect(0, 0, 10, 10));
-  // Test composite operators with an opaque rect that does not cover the entire canvas
+  // Test composite operators with an opaque rect that does not cover the entire
+  // canvas
   TEST_OVERDRAW_2(0, setGlobalCompositeOperation(String("clear")),
                   fillRect(0, 0, 5, 5));
   TEST_OVERDRAW_2(1, setGlobalCompositeOperation(String("copy")),
                   fillRect(0, 0, 5, 5));
   TEST_OVERDRAW_2(0, setGlobalCompositeOperation(String("source-over")),
                   fillRect(0, 0, 5, 5));
   TEST_OVERDRAW_2(0, setGlobalCompositeOperation(String("source-in")),
                   fillRect(0, 0, 5, 5));
 }
 
@@ skipping 369 matching lines @@
   createContext(NonOpaque);
 
   std::unique_ptr<FakeAcceleratedImageBufferSurfaceForTesting>
       fakeAccelerateSurface =
           wrapUnique(new FakeAcceleratedImageBufferSurfaceForTesting(
               IntSize(10, 10), NonOpaque));
   FakeAcceleratedImageBufferSurfaceForTesting* fakeAccelerateSurfacePtr =
       fakeAccelerateSurface.get();
   canvasElement().createImageBufferUsingSurfaceForTesting(
       std::move(fakeAccelerateSurface));
-  // 800 = 10 * 10 * 4 * 2 where 10*10 is canvas size, 4 is num of bytes per pixel per buffer,
-  // and 2 is an estimate of num of gpu buffers required
+  // 800 = 10 * 10 * 4 * 2 where 10*10 is canvas size, 4 is num of bytes per
+  // pixel per buffer, and 2 is an estimate of num of gpu buffers required
   EXPECT_EQ(800, getCurrentGPUMemoryUsage());
   EXPECT_EQ(800, getGlobalGPUMemoryUsage());
   EXPECT_EQ(1u, getGlobalAcceleratedImageBufferCount());
 
   // Switching accelerated mode to non-accelerated mode
   fakeAccelerateSurfacePtr->setIsAccelerated(false);
   canvasElement().buffer()->updateGPUMemoryUsage();
   EXPECT_EQ(0, getCurrentGPUMemoryUsage());
   EXPECT_EQ(0, getGlobalGPUMemoryUsage());
   EXPECT_EQ(0u, getGlobalAcceleratedImageBufferCount());
@@ skipping 193 matching lines @@
   createContext(NonOpaque);
 
   std::unique_ptr<FakeAcceleratedImageBufferSurfaceForTesting>
       fakeAccelerateSurface =
           wrapUnique(new FakeAcceleratedImageBufferSurfaceForTesting(
               IntSize(10, 10), NonOpaque));
   canvasElement().createImageBufferUsingSurfaceForTesting(
       std::move(fakeAccelerateSurface));
   CanvasRenderingContext2D* context = context2d();
 
-  // 800 = 10 * 10 * 4 * 2 where 10*10 is canvas size, 4 is num of bytes per pixel per buffer,
-  // and 2 is an estimate of num of gpu buffers required
+  // 800 = 10 * 10 * 4 * 2 where 10*10 is canvas size, 4 is num of bytes per
+  // pixel per buffer, and 2 is an estimate of num of gpu buffers required
   EXPECT_EQ(800, getCurrentGPUMemoryUsage());
   EXPECT_EQ(800, getGlobalGPUMemoryUsage());
   EXPECT_EQ(1u, getGlobalAcceleratedImageBufferCount());
 
   context->fillRect(10, 10, 100, 100);
   EXPECT_TRUE(canvasElement().buffer()->isAccelerated());
 
   canvasElement().buffer()->disableAcceleration();
   EXPECT_FALSE(canvasElement().buffer()->isAccelerated());
 
   context->fillRect(10, 10, 100, 100);
 
   EXPECT_EQ(0, getCurrentGPUMemoryUsage());
   EXPECT_EQ(0, getGlobalGPUMemoryUsage());
   EXPECT_EQ(0u, getGlobalAcceleratedImageBufferCount());
 }
 
 }  // namespace blink