Reflow comments in canvas-related folders

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

 /*
- * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
+ * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc.
+ * All rights reserved.
  * Copyright (C) 2008, 2010 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2007 Alp Toker <alp@atoker.com>
  * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008 Dirk Schulze <krit@webkit.org>
  * Copyright (C) 2010 Torch Mobile (Beijing) Co. Ltd. All rights reserved.
  * Copyright (C) 2012, 2013 Intel Corporation. All rights reserved.
  * Copyright (C) 2013 Adobe Systems Incorporated. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ skipping 60 matching lines @@
 static const char rtl[] = "rtl";
 static const char ltr[] = "ltr";
 static const double TryRestoreContextInterval = 0.5;
 static const unsigned MaxTryRestoreContextAttempts = 4;
 static const double cDeviceScaleFactor = 1.0;  // Canvas is device independent
 
 static bool contextLostRestoredEventsEnabled() {
   return RuntimeEnabledFeatures::experimentalCanvasFeaturesEnabled();
 }
 
-// Drawing methods need to use this instead of SkAutoCanvasRestore in case overdraw
-// detection substitutes the recording canvas (to discard overdrawn draw calls).
+// Drawing methods need to use this instead of SkAutoCanvasRestore in case
+// overdraw detection substitutes the recording canvas (to discard overdrawn
+// draw calls).
 class CanvasRenderingContext2DAutoRestoreSkCanvas {
   STACK_ALLOCATED();
 
  public:
   explicit CanvasRenderingContext2DAutoRestoreSkCanvas(
       CanvasRenderingContext2D* context)
       : m_context(context), m_saveCount(0) {
     ASSERT(m_context);
     SkCanvas* c = m_context->drawingCanvas();
     if (c) {
@@ skipping 126 matching lines @@
 
 void CanvasRenderingContext2D::dispatchContextLostEvent(TimerBase*) {
   if (canvas() && contextLostRestoredEventsEnabled()) {
     Event* event = Event::createCancelable(EventTypeNames::contextlost);
     canvas()->dispatchEvent(event);
     if (event->defaultPrevented()) {
       m_contextRestorable = false;
     }
   }
 
-  // If RealLostContext, it means the context was not lost due to surface failure
-  // but rather due to a an eviction, which means image buffer exists.
+  // If RealLostContext, it means the context was not lost due to surface
+  // failure but rather due to a an eviction, which means image buffer exists.
   if (m_contextRestorable && m_contextLostMode == RealLostContext) {
     m_tryRestoreContextAttemptCount = 0;
     m_tryRestoreContextEventTimer.startRepeating(TryRestoreContextInterval,
                                                  BLINK_FROM_HERE);
   }
 }
 
 void CanvasRenderingContext2D::tryRestoreContextEvent(TimerBase* timer) {
   if (m_contextLostMode == NotLostContext) {
-    // Canvas was already restored (possibly thanks to a resize), so stop trying.
+    // Canvas was already restored (possibly thanks to a resize), so stop
+    // trying.
     m_tryRestoreContextEventTimer.stop();
     return;
   }
 
   DCHECK(m_contextLostMode == RealLostContext);
   if (canvas()->hasImageBuffer() && canvas()->buffer()->restoreSurface()) {
     m_tryRestoreContextEventTimer.stop();
     dispatchContextRestoredEvent(nullptr);
   }
 
@@ skipping 70 matching lines @@
 
   // Offset by the canvas rect
   LayoutRect pathRect(boundingRect);
   IntRect canvasRect = layoutBox->absoluteContentBox();
   pathRect.moveBy(canvasRect.location());
 
   renderer->scrollRectToVisible(pathRect, ScrollAlignment::alignCenterAlways,
                                 ScrollAlignment::alignTopAlways);
 
   // TODO: should implement "inform the user" that the caret and/or
-  // selection the specified rectangle of the canvas. See http://crbug.com/357987
+  // selection the specified rectangle of the canvas. See
+  // http://crbug.com/357987
 }
 
 void CanvasRenderingContext2D::clearRect(double x,
                                          double y,
                                          double width,
                                          double height) {
   BaseRenderingContext2D::clearRect(x, y, width, height);
 
   if (m_hitRegionManager) {
     FloatRect rect(x, y, width, height);
@@ skipping 17 matching lines @@
 
 bool CanvasRenderingContext2D::stateHasFilter() {
   return state().hasFilter(canvas(), canvas()->size(), this);
 }
 
 SkImageFilter* CanvasRenderingContext2D::stateGetFilter() {
   return state().getFilter(canvas(), canvas()->size(), this);
 }
 
 void CanvasRenderingContext2D::snapshotStateForFilter() {
-  // The style resolution required for fonts is not available in frame-less documents.
+  // The style resolution required for fonts is not available in frame-less
+  // documents.
   if (!canvas()->document().frame())
     return;
 
   modifiableState().setFontForFilter(accessFont());
 }
 
 SkCanvas* CanvasRenderingContext2D::drawingCanvas() const {
   if (isContextLost())
     return nullptr;
   return canvas()->drawingCanvas();
@@ skipping 28 matching lines @@
 
   serializedFont.appendNumber(fontDescription.computedPixelSize());
   serializedFont.append("px");
 
   const FontFamily& firstFontFamily = fontDescription.family();
   for (const FontFamily* fontFamily = &firstFontFamily; fontFamily;
        fontFamily = fontFamily->next()) {
     if (fontFamily != &firstFontFamily)
       serializedFont.append(',');
 
-    // FIXME: We should append family directly to serializedFont rather than building a temporary string.
+    // FIXME: We should append family directly to serializedFont rather than
+    // building a temporary string.
     String family = fontFamily->family();
     if (family.startsWith("-webkit-"))
       family = family.substring(8);
     if (family.contains(' '))
       family = "\"" + family + "\"";
 
     serializedFont.append(' ');
     serializedFont.append(family);
   }
 
   return serializedFont.toString();
 }
 
 void CanvasRenderingContext2D::setFont(const String& newFont) {
-  // The style resolution required for fonts is not available in frame-less documents.
+  // The style resolution required for fonts is not available in frame-less
+  // documents.
   if (!canvas()->document().frame())
     return;
 
   canvas()->document().updateStyleAndLayoutTreeForNode(canvas());
 
   // The following early exit is dependent on the cache not being empty
   // because an empty cache may indicate that a style change has occured
   // which would require that the font be re-resolved. This check has to
   // come after the layout tree update to flush pending style changes.
   if (newFont == state().unparsedFont() && state().hasRealizedFont() &&
       m_fontsResolvedUsingCurrentStyle.size() > 0)
     return;
 
   CanvasFontCache* canvasFontCache = canvas()->document().canvasFontCache();
 
-  // Map the <canvas> font into the text style. If the font uses keywords like larger/smaller, these will work
-  // relative to the canvas.
+  // Map the <canvas> font into the text style. If the font uses keywords like
+  // larger/smaller, these will work relative to the canvas.
   RefPtr<ComputedStyle> fontStyle;
   const ComputedStyle* computedStyle = canvas()->ensureComputedStyle();
   if (computedStyle) {
     HashMap<String, Font>::iterator i =
         m_fontsResolvedUsingCurrentStyle.find(newFont);
     if (i != m_fontsResolvedUsingCurrentStyle.end()) {
       ASSERT(m_fontLRUList.contains(newFont));
       m_fontLRUList.remove(newFont);
       m_fontLRUList.add(newFont);
       modifiableState().setFont(
           i->value, canvas()->document().styleEngine().fontSelector());
     } else {
       MutableStylePropertySet* parsedStyle =
           canvasFontCache->parseFont(newFont);
       if (!parsedStyle)
         return;
       fontStyle = ComputedStyle::create();
       FontDescription elementFontDescription(
           computedStyle->getFontDescription());
-      // Reset the computed size to avoid inheriting the zoom factor from the <canvas> element.
+      // Reset the computed size to avoid inheriting the zoom factor from the
+      // <canvas> element.
       elementFontDescription.setComputedSize(
           elementFontDescription.specifiedSize());
       fontStyle->setFontDescription(elementFontDescription);
       fontStyle->font().update(fontStyle->font().getFontSelector());
       canvas()->document().ensureStyleResolver().computeFont(fontStyle.get(),
                                                              *parsedStyle);
       m_fontsResolvedUsingCurrentStyle.add(newFont, fontStyle->font());
       ASSERT(!m_fontLRUList.contains(newFont));
       m_fontLRUList.add(newFont);
       pruneLocalFontCache(canvasFontCache->hardMaxFonts());  // hard limit
       schedulePruneLocalFontCacheIfNeeded();                 // soft limit
       modifiableState().setFont(
           fontStyle->font(), canvas()->document().styleEngine().fontSelector());
     }
   } else {
     Font resolvedFont;
     if (!canvasFontCache->getFontUsingDefaultStyle(newFont, resolvedFont))
       return;
     modifiableState().setFont(
         resolvedFont, canvas()->document().styleEngine().fontSelector());
   }
 
   // The parse succeeded.
-  String newFontSafeCopy(
-      newFont);  // Create a string copy since newFont can be deleted inside realizeSaves.
+  String newFontSafeCopy(newFont);  // Create a string copy since newFont can be
+                                    // deleted inside realizeSaves.
   modifiableState().setUnparsedFont(newFontSafeCopy);
 }
 
 void CanvasRenderingContext2D::schedulePruneLocalFontCacheIfNeeded() {
   if (m_pruneLocalFontCacheScheduled)
     return;
   m_pruneLocalFontCacheScheduled = true;
   Platform::current()->currentThread()->addTaskObserver(this);
 }
 
 void CanvasRenderingContext2D::didProcessTask() {
   Platform::current()->currentThread()->removeTaskObserver(this);
 
-  // This should be the only place where canvas() needs to be checked for nullness
-  // because the circular refence with HTMLCanvasElement mean the canvas and the
-  // context keep each other alive as long as the pair is referenced the task
-  // observer is the only persisten refernce to this object that is not traced,
-  // so didProcessTask() may be call at a time when the canvas has been garbage
-  // collected but not the context.
+  // This should be the only place where canvas() needs to be checked for
+  // nullness because the circular refence with HTMLCanvasElement mean the
+  // canvas and the context keep each other alive as long as the pair is
+  // referenced the task observer is the only persisten refernce to this object
+  // that is not traced, so didProcessTask() may be call at a time when the
+  // canvas has been garbage collected but not the context.
   if (!canvas())
     return;
 
   // The rendering surface needs to be prepared now because it will be too late
   // to create a layer once we are in the paint invalidation phase.
   canvas()->prepareSurfaceForPaintingIfNeeded();
 
   pruneLocalFontCache(canvas()->document().canvasFontCache()->maxFonts());
   m_pruneLocalFontCacheScheduled = false;
 }
@@ skipping 192 matching lines @@
                                           double y,
                                           double maxWidth) {
   trackDrawCall(StrokeText);
   drawTextInternal(text, x, y, CanvasRenderingContext2DState::StrokePaintType,
                    &maxWidth);
 }
 
 TextMetrics* CanvasRenderingContext2D::measureText(const String& text) {
   TextMetrics* metrics = TextMetrics::create();
 
-  // The style resolution required for fonts is not available in frame-less documents.
+  // The style resolution required for fonts is not available in frame-less
+  // documents.
   if (!canvas()->document().frame())
     return metrics;
 
   canvas()->document().updateStyleAndLayoutTreeForNode(canvas());
   const Font& font = accessFont();
 
   TextDirection direction;
   if (state().getDirection() == CanvasRenderingContext2DState::DirectionInherit)
     direction = determineDirectionality(text);
   else
@@ skipping 15 matching lines @@
   const FontMetrics& fontMetrics = font.getFontMetrics();
   const float ascent = fontMetrics.floatAscent();
   const float descent = fontMetrics.floatDescent();
   const float baselineY = getFontBaseline(fontMetrics);
 
   metrics->setFontBoundingBoxAscent(ascent - baselineY);
   metrics->setFontBoundingBoxDescent(descent + baselineY);
   metrics->setActualBoundingBoxAscent(-textBounds.y() - baselineY);
   metrics->setActualBoundingBoxDescent(textBounds.maxY() + baselineY);
 
-  // Note : top/bottom and ascend/descend are currently the same, so there's no difference
-  //        between the EM box's top and bottom and the font's ascend and descend
+  // Note : top/bottom and ascend/descend are currently the same, so there's no
+  // difference between the EM box's top and bottom and the font's ascend and
+  // descend
   metrics->setEmHeightAscent(0);
   metrics->setEmHeightDescent(0);
 
   metrics->setHangingBaseline(0.8f * ascent - baselineY);
   metrics->setAlphabeticBaseline(-baselineY);
   metrics->setIdeographicBaseline(-descent - baselineY);
   return metrics;
 }
 
 void CanvasRenderingContext2D::drawTextInternal(
     const String& text,
     double x,
     double y,
     CanvasRenderingContext2DState::PaintType paintType,
     double* maxWidth) {
-  // The style resolution required for fonts is not available in frame-less documents.
+  // The style resolution required for fonts is not available in frame-less
+  // documents.
   if (!canvas()->document().frame())
     return;
 
-  // accessFont needs the style to be up to date, but updating style can cause script to run,
-  // (e.g. due to autofocus) which can free the canvas (set size to 0, for example), so update
-  // style before grabbing the drawingCanvas.
+  // accessFont needs the style to be up to date, but updating style can cause
+  // script to run, (e.g. due to autofocus) which can free the canvas (set size
+  // to 0, for example), so update style before grabbing the drawingCanvas.
   canvas()->document().updateStyleAndLayoutTreeForNode(canvas());
 
   SkCanvas* c = drawingCanvas();
   if (!c)
     return;
 
   if (!std::isfinite(x) || !std::isfinite(y))
     return;
   if (maxWidth && (!std::isfinite(*maxWidth) || *maxWidth <= 0))
     return;
 
-  // Currently, SkPictureImageFilter does not support subpixel text anti-aliasing, which
-  // is expected when !creationAttributes().alpha(), so we need to fall out of display
-  // list mode when drawing text to an opaque canvas.
-  // crbug.com/583809
+  // Currently, SkPictureImageFilter does not support subpixel text
+  // anti-aliasing, which is expected when !creationAttributes().alpha(), so we
+  // need to fall out of display list mode when drawing text to an opaque
+  // canvas. crbug.com/583809
   if (!creationAttributes().alpha() && !isAccelerated())
     canvas()->disableDeferral(
         DisableDeferralReasonSubPixelTextAntiAliasingSupport);
 
   const Font& font = accessFont();
   if (!font.primaryFont())
     return;
 
   const FontMetrics& fontMetrics = font.getFontMetrics();
 
@@ skipping 26 matching lines @@
     case CenterTextAlign:
       location.setX(location.x() - width / 2);
       break;
     case RightTextAlign:
       location.setX(location.x() - width);
       break;
     default:
       break;
   }
 
-  // The slop built in to this mask rect matches the heuristic used in FontCGWin.cpp for GDI text.
+  // The slop built in to this mask rect matches the heuristic used in
+  // FontCGWin.cpp for GDI text.
   TextRunPaintInfo textRunPaintInfo(textRun);
   textRunPaintInfo.bounds =
       FloatRect(location.x() - fontMetrics.height() / 2,
                 location.y() - fontMetrics.ascent() - fontMetrics.lineGap(),
                 width + fontMetrics.height(), fontMetrics.lineSpacing());
   if (paintType == CanvasRenderingContext2DState::StrokePaintType)
     inflateStrokeRect(textRunPaintInfo.bounds);
 
   CanvasRenderingContext2DAutoRestoreSkCanvas stateRestorer(this);
   if (useMaxWidth) {
     drawingCanvas()->save();
     drawingCanvas()->translate(location.x(), location.y());
-    // We draw when fontWidth is 0 so compositing operations (eg, a "copy" op) still work.
+    // We draw when fontWidth is 0 so compositing operations (eg, a "copy" op)
+    // still work.
     drawingCanvas()->scale((fontWidth > 0 ? (width / fontWidth) : 0), 1);
     location = FloatPoint();
   }
 
   draw(
       [&font, this, &textRunPaintInfo, &location](
           SkCanvas* c, const SkPaint* paint)  // draw lambda
       {
         font.drawBidiText(c, textRunPaintInfo, location,
                           Font::UseFallbackIfFontNotReady, cDeviceScaleFactor,
@@ skipping 10 matching lines @@
   canvas()->document().canvasFontCache()->willUseCurrentFont();
   return state().font();
 }
 
 int CanvasRenderingContext2D::getFontBaseline(
     const FontMetrics& fontMetrics) const {
   switch (state().getTextBaseline()) {
     case TopTextBaseline:
       return fontMetrics.ascent();
     case HangingTextBaseline:
-      // According to http://wiki.apache.org/xmlgraphics-fop/LineLayout/AlignmentHandling
-      // "FOP (Formatting Objects Processor) puts the hanging baseline at 80% of the ascender height"
+      // According to
+      // http://wiki.apache.org/xmlgraphics-fop/LineLayout/AlignmentHandling
+      // "FOP (Formatting Objects Processor) puts the hanging baseline at 80% of
+      // the ascender height"
       return (fontMetrics.ascent() * 4) / 5;
     case BottomTextBaseline:
     case IdeographicTextBaseline:
       return -fontMetrics.descent();
     case MiddleTextBaseline:
       return -fontMetrics.descent() + fontMetrics.height() / 2;
     case AlphabeticTextBaseline:
     default:
       // Do nothing.
       break;
@@ skipping 176 matching lines @@
 
 unsigned CanvasRenderingContext2D::hitRegionsCount() const {
   if (m_hitRegionManager)
     return m_hitRegionManager->getHitRegionsCount();
 
   return 0;
 }
 
 bool CanvasRenderingContext2D::isAccelerationOptimalForCanvasContent() const {
   // Heuristic to determine if the GPU accelerated rendering pipeline is optimal
-  // for performance based on past usage. It has a bias towards suggesting that the
-  // accelerated pipeline is optimal.
+  // for performance based on past usage. It has a bias towards suggesting that
+  // the accelerated pipeline is optimal.
 
   float acceleratedCost = estimateRenderingCost(
       ExpensiveCanvasHeuristicParameters::AcceleratedModeIndex);
 
   float recordingCost = estimateRenderingCost(
       ExpensiveCanvasHeuristicParameters::RecordingModeIndex);
 
   float costDifference = acceleratedCost - recordingCost;
   float percentCostReduction = costDifference / acceleratedCost * 100.0;
   float costDifferencePerFrame =
       costDifference / m_usageCounters.numFramesSinceReset;
 
   if (percentCostReduction >=
           ExpensiveCanvasHeuristicParameters::
               MinPercentageImprovementToSuggestDisableAcceleration &&
       costDifferencePerFrame >=
           ExpensiveCanvasHeuristicParameters::
               MinCostPerFrameImprovementToSuggestDisableAcceleration) {
     return false;
   }
   return true;
 }
 
 void CanvasRenderingContext2D::resetUsageTracking() {
   UsageCounters newCounters;
   m_usageCounters = newCounters;
 }
 
 }  // namespace blink