Reflow comments in canvas-related folders

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

 // Copyright 2016 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/BaseRenderingContext2D.h"
 
 #include "bindings/core/v8/ExceptionMessages.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ExceptionStatePlaceholder.h"
 #include "core/css/cssom/CSSURLImageValue.h"
@@ skipping 34 matching lines @@
 
 void BaseRenderingContext2D::realizeSaves() {
   validateStateStack();
   if (state().hasUnrealizedSaves()) {
     ASSERT(m_stateStack.size() >= 1);
     // Reduce the current state's unrealized count by one now,
     // to reflect the fact we are saving one state.
     m_stateStack.last()->restore();
     m_stateStack.append(CanvasRenderingContext2DState::create(
         state(), CanvasRenderingContext2DState::DontCopyClipList));
-    // Set the new state's unrealized count to 0, because it has no outstanding saves.
-    // We need to do this explicitly because the copy constructor and operator= used
-    // by the Vector operations copy the unrealized count from the previous state (in
-    // turn necessary to support correct resizing and unwinding of the stack).
+    // Set the new state's unrealized count to 0, because it has no outstanding
+    // saves.
+    // We need to do this explicitly because the copy constructor and operator=
+    // used by the Vector operations copy the unrealized count from the previous
+    // state (in turn necessary to support correct resizing and unwinding of the
+    // stack).
     m_stateStack.last()->resetUnrealizedSaveCount();
     SkCanvas* canvas = drawingCanvas();
     if (canvas)
       canvas->save();
     validateStateStack();
   }
 }
 
 void BaseRenderingContext2D::save() {
   m_stateStack.last()->save();
@@ skipping 423 matching lines @@
   // When CTM becomes non-invertible, realizeSaves() can make CTM identity.
   if (ctm.isIdentity() && invertibleCTM)
     return;
 
   // resetTransform() resolves the non-invertible CTM state.
   modifiableState().resetTransform();
   c->setMatrix(affineTransformToSkMatrix(baseTransform()));
 
   if (invertibleCTM)
     m_path.transform(ctm);
-  // When else, do nothing because all transform methods didn't update m_path when CTM became non-invertible.
-  // It means that resetTransform() restores m_path just before CTM became non-invertible.
+  // When else, do nothing because all transform methods didn't update m_path
+  // when CTM became non-invertible.
+  // It means that resetTransform() restores m_path just before CTM became
+  // non-invertible.
 }
 
 void BaseRenderingContext2D::setTransform(double m11,
                                           double m12,
                                           double m21,
                                           double m22,
                                           double dx,
                                           double dy) {
   SkCanvas* c = drawingCanvas();
   if (!c)
@@ skipping 30 matching lines @@
   if (height < 0) {
     height = -height;
     y -= height;
   }
 
   return true;
 }
 
 bool BaseRenderingContext2D::isFullCanvasCompositeMode(SkXfermode::Mode op) {
   // See 4.8.11.1.3 Compositing
-  // CompositeSourceAtop and CompositeDestinationOut are not listed here as the platforms already
-  // implement the specification's behavior.
+  // CompositeSourceAtop and CompositeDestinationOut are not listed here as the
+  // platforms already implement the specification's behavior.
   return op == SkXfermode::kSrcIn_Mode || op == SkXfermode::kSrcOut_Mode ||
          op == SkXfermode::kDstIn_Mode || op == SkXfermode::kDstATop_Mode;
 }
 
 static bool isPathExpensive(const Path& path) {
   const SkPath& skPath = path.getSkPath();
   if (ExpensiveCanvasHeuristicParameters::ConcavePathsAreExpensive &&
       !skPath.isConvex())
     return true;
 
@@ skipping 280 matching lines @@
 
   // Compute the src to dst transform
   FloatSize scale(dstRect->size().width() / srcRect->size().width(),
                   dstRect->size().height() / srcRect->size().height());
   FloatPoint scaledSrcLocation = srcRect->location();
   scaledSrcLocation.scale(scale.width(), scale.height());
   FloatSize offset = dstRect->location() - scaledSrcLocation;
 
   srcRect->intersect(imageRect);
 
-  // To clip the destination rectangle in the same proportion, transform the clipped src rect
+  // To clip the destination rectangle in the same proportion, transform the
+  // clipped src rect
   *dstRect = *srcRect;
   dstRect->scale(scale.width(), scale.height());
   dstRect->move(offset);
 }
 
 static inline CanvasImageSource* toImageSourceInternal(
     const CanvasImageSourceUnion& value,
     ExceptionState& exceptionState) {
   if (value.isCSSImageValue()) {
     if (RuntimeEnabledFeatures::cssPaintAPIEnabled())
@@ skipping 262 matching lines @@
     return;
 
   DisableDeferralReason reason = DisableDeferralReasonUnknown;
   if (shouldDisableDeferral(imageSource, &reason))
     disableDeferral(reason);
   else if (image->isTextureBacked())
     disableDeferral(DisableDeferralDrawImageWithTextureBackedSourceImage);
 
   validateStateStack();
 
-  // Heuristic for disabling acceleration based on anticipated texture upload overhead
+  // Heuristic for disabling acceleration based on anticipated texture upload
+  // overhead.
   // See comments in ExpensiveCanvasHeuristicParameters.h for explanation.
   ImageBuffer* buffer = imageBuffer();
   if (buffer && buffer->isAccelerated() && !imageSource->isAccelerated()) {
     float srcArea = srcRect.width() * srcRect.height();
     if (srcArea > ExpensiveCanvasHeuristicParameters::
                       DrawImageTextureUploadHardSizeLimit) {
       buffer->disableAcceleration();
     } else if (srcArea > ExpensiveCanvasHeuristicParameters::
                              DrawImageTextureUploadSoftSizeLimit) {
       SkRect bounds = dstRect;
@@ skipping 559 matching lines @@
     if (paint->getLooper() || paint->getImageFilter() || paint->getMaskFilter())
       return;
 
     SkXfermode* xfermode = paint->getXfermode();
     if (xfermode) {
       SkXfermode::Mode mode;
       if (xfermode->asMode(&mode)) {
         isSourceOver = mode == SkXfermode::kSrcOver_Mode;
         if (!isSourceOver && mode != SkXfermode::kSrc_Mode &&
             mode != SkXfermode::kClear_Mode)
-          return;  // The code below only knows how to handle Src, SrcOver, and Clear
+          return;  // The code below only knows how to handle Src, SrcOver, and
+                   // Clear
       } else {
         // unknown xfermode
         ASSERT_NOT_REACHED();
         return;
       }
     }
 
     alpha = paint->getAlpha();
 
     if (isSourceOver && imageType == CanvasRenderingContext2DState::NoImage) {
@@ skipping 252 matching lines @@
       ExpensiveCanvasHeuristicParameters::ShadowFixedCost[index] *
           m_usageCounters.numBlurredShadows +
       ExpensiveCanvasHeuristicParameters::
               ShadowVariableCostPerAreaTimesShadowBlurSquared[index] *
           m_usageCounters.boundingBoxAreaTimesShadowBlurSquared;
 
   return basicCostOfDrawCalls + fillTypeAdjustment + shadowAdjustment;
 }
 
 }  // namespace blink