reflow comments in core/html/*.{cpp,h},core/html/imports

third_party/WebKit/Source/core/html/HTMLCanvasElement.cpp

 /*
  * Copyright (C) 2004, 2006, 2007 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alp Toker <alp@atoker.com>
  * Copyright (C) 2010 Torch Mobile (Beijing) Co. Ltd. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
@@ skipping 240 matching lines @@
     contextTypeHistogram.count(contextType);
   }
 
   contextType = CanvasRenderingContext::resolveContextTypeAliases(contextType);
 
   CanvasRenderingContextFactory* factory =
       getRenderingContextFactory(contextType);
   if (!factory)
     return nullptr;
 
-  // FIXME - The code depends on the context not going away once created, to prevent JS from
-  // seeing a dangling pointer. So for now we will disallow the context from being changed
-  // once it is created.
+  // FIXME - The code depends on the context not going away once created, to
+  // prevent JS from seeing a dangling pointer. So for now we will disallow the
+  // context from being changed once it is created.
   if (m_context) {
     if (m_context->getContextType() == contextType)
       return m_context.get();
 
     factory->onError(this,
                      "Canvas has an existing context of a different type");
     return nullptr;
   }
 
   m_context = factory->create(this, attributes, document());
@@ skipping 68 matching lines @@
 
   m_numFramesSinceLastRenderingModeSwitch++;
   if (RuntimeEnabledFeatures::
           enableCanvas2dDynamicRenderingModeSwitchingEnabled() &&
       !RuntimeEnabledFeatures::canvas2dFixedRenderingModeEnabled()) {
     if (m_context->is2d() && buffer() && buffer()->isAccelerated() &&
         m_numFramesSinceLastRenderingModeSwitch >=
             ExpensiveCanvasHeuristicParameters::MinFramesBeforeSwitch &&
         !m_pendingRenderingModeSwitch) {
       if (!m_context->isAccelerationOptimalForCanvasContent()) {
-        // The switch must be done asynchronously in order to avoid switching during the paint invalidation step.
+        // The switch must be done asynchronously in order to avoid switching
+        // during the paint invalidation step.
         Platform::current()->currentThread()->getWebTaskRunner()->postTask(
             BLINK_FROM_HERE,
             WTF::bind(
                 [](WeakPtr<ImageBuffer> buffer) {
                   if (buffer) {
                     buffer->disableAcceleration();
                   }
                 },
                 m_imageBuffer->m_weakPtrFactory.createWeakPtr()));
         m_numFramesSinceLastRenderingModeSwitch = 0;
@@ skipping 26 matching lines @@
     didFinalizeFrame();
   } else {
     DCHECK(hasImageBuffer());
     FloatRect srcRect(0, 0, size().width(), size().height());
     m_dirtyRect.intersect(srcRect);
     LayoutBox* lb = layoutBox();
     if (lb) {
       FloatRect mappedDirtyRect =
           mapRect(m_dirtyRect, srcRect, FloatRect(lb->contentBoxRect()));
       if (m_context->isAccelerated()) {
-        // Accelerated 2D canvases need the dirty rect to be expressed relative to the
-        // content box, as opposed to the layout box.
+        // Accelerated 2D canvases need the dirty rect to be expressed relative
+        // to the content box, as opposed to the layout box.
         mappedDirtyRect.move(-lb->contentBoxOffset());
       }
       m_imageBuffer->finalizeFrame(mappedDirtyRect);
     } else {
       m_imageBuffer->finalizeFrame(m_dirtyRect);
     }
   }
   DCHECK(m_dirtyRect.isEmpty());
 }
 
@@ skipping 13 matching lines @@
   int h = getAttribute(heightAttr).toInt(&ok);
   if (!ok || h < 0)
     h = DefaultHeight;
 
   if (m_context && m_context->is2d())
     m_context->reset();
 
   IntSize oldSize = size();
   IntSize newSize(w, h);
 
-  // If the size of an existing buffer matches, we can just clear it instead of reallocating.
-  // This optimization is only done for 2D canvases for now.
+  // If the size of an existing buffer matches, we can just clear it instead of
+  // reallocating.  This optimization is only done for 2D canvases for now.
   if (hadImageBuffer && oldSize == newSize && m_context && m_context->is2d() &&
       !buffer()->isRecording()) {
     if (!m_imageBufferIsClear) {
       m_imageBufferIsClear = true;
       m_context->clearRect(0, 0, width(), height());
     }
     return;
   }
 
   setSurfaceSize(newSize);
@@ skipping 51 matching lines @@
     sk_sp<SkImage> image = sourceImage->imageForCurrentFrame();
     for (CanvasDrawListener* listener : m_listeners) {
       if (listener->needsNewFrame()) {
         listener->sendNewFrame(image);
       }
     }
   }
 }
 
 void HTMLCanvasElement::paint(GraphicsContext& context, const LayoutRect& r) {
-  // FIXME: crbug.com/438240; there is a bug with the new CSS blending and compositing feature.
+  // FIXME: crbug.com/438240; there is a bug with the new CSS blending and
+  // compositing feature.
   if (!m_context)
     return;
 
   const ComputedStyle* style = ensureComputedStyle();
   SkFilterQuality filterQuality =
       (style && style->imageRendering() == ImageRenderingPixelated)
           ? kNone_SkFilterQuality
           : kLow_SkFilterQuality;
 
   if (is3D()) {
@@ skipping 100 matching lines @@
     toDataURLImageFormatHistogram.count(imageFormat);
   } else if (encodeReason == EncodeReasonToBlobCallback) {
     DEFINE_THREAD_SAFE_STATIC_LOCAL(
         EnumerationHistogram, toBlobCallbackImageFormatHistogram,
         new EnumerationHistogram(
             "Canvas.RequestedImageMimeTypes_toBlobCallback",
             NumberOfRequestedImageMimeTypes));
     toBlobCallbackImageFormatHistogram.count(imageFormat);
   }
 
-  // FIXME: Make isSupportedImageMIMETypeForEncoding threadsafe (to allow this method to be used on a worker thread).
+  // FIXME: Make isSupportedImageMIMETypeForEncoding threadsafe (to allow this
+  // method to be used on a worker thread).
   if (!MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(lowercaseMimeType))
     lowercaseMimeType = DefaultMimeType;
   return lowercaseMimeType;
 }
 
 const AtomicString HTMLCanvasElement::imageSourceURL() const {
   return AtomicString(toDataURLInternal(DefaultMimeType, 0, FrontBuffer));
 }
 
 void HTMLCanvasElement::prepareSurfaceForPaintingIfNeeded() const {
   DCHECK(m_context &&
          m_context->is2d());  // This function is called by the 2d context
   if (buffer())
     m_imageBuffer->prepareSurfaceForPaintingIfNeeded();
 }
 
 ImageData* HTMLCanvasElement::toImageData(SourceDrawingBuffer sourceBuffer,
                                           SnapshotReason reason) const {
   ImageData* imageData;
   if (is3D()) {
-    // Get non-premultiplied data because of inaccurate premultiplied alpha conversion of buffer()->toDataURL().
+    // Get non-premultiplied data because of inaccurate premultiplied alpha
+    // conversion of buffer()->toDataURL().
     imageData = m_context->paintRenderingResultsToImageData(sourceBuffer);
     if (imageData)
       return imageData;
 
     m_context->paintRenderingResultsToCanvas(sourceBuffer);
     imageData = ImageData::create(m_size);
     if (imageData && hasImageBuffer()) {
       sk_sp<SkImage> snapshot =
           buffer()->newSkImageSnapshot(PreferNoAcceleration, reason);
       if (snapshot) {
@@ skipping 204 matching lines @@
   if (m_context && !m_context->is2d())
     return false;
 
   if (RuntimeEnabledFeatures::forceDisplayList2dCanvasEnabled())
     return false;
 
   if (!RuntimeEnabledFeatures::accelerated2dCanvasEnabled())
     return false;
 
   // The following is necessary for handling the special case of canvases in the
-  // dev tools overlay, which run in a process that supports accelerated 2d canvas
-  // but in a special compositing context that does not.
+  // dev tools overlay, which run in a process that supports accelerated 2d
+  // canvas but in a special compositing context that does not.
   if (layoutBox() && !layoutBox()->hasAcceleratedCompositing())
     return false;
 
   CheckedNumeric<int> checkedCanvasPixelCount = size.width();
   checkedCanvasPixelCount *= size.height();
   if (!checkedCanvasPixelCount.IsValid())
     return false;
   int canvasPixelCount = checkedCanvasPixelCount.ValueOrDie();
 
   if (RuntimeEnabledFeatures::displayList2dCanvasEnabled()) {
@@ skipping 123 matching lines @@
     sk_sp<SkColorSpace> colorSpace) {
   if (shouldUseDisplayList(deviceSize)) {
     auto surface = wrapUnique(new RecordingImageBufferSurface(
         deviceSize, wrapUnique(new UnacceleratedSurfaceFactory), opacityMode,
         colorSpace));
     if (surface->isValid()) {
       CanvasMetrics::countCanvasContextUsage(
           CanvasMetrics::DisplayList2DCanvasImageBufferCreated);
       return std::move(surface);
     }
-    // We fallback to a non-display-list surface without recording a metric here.
+    // We fallback to a non-display-list surface without recording a metric
+    // here.
   }
 
   auto surfaceFactory = wrapUnique(new UnacceleratedSurfaceFactory());
   auto surface = surfaceFactory->createSurface(deviceSize, opacityMode,
                                                std::move(colorSpace));
   if (surface->isValid()) {
     CanvasMetrics::countCanvasContextUsage(
         CanvasMetrics::Unaccelerated2DCanvasImageBufferCreated);
     return surface;
   }
@@ skipping 47 matching lines @@
   m_didFailToCreateImageBuffer = false;
 
   updateExternallyAllocatedMemory();
 
   if (is3D()) {
     // Early out for WebGL canvases
     return;
   }
 
   m_imageBuffer->setClient(this);
-  // Enabling MSAA overrides a request to disable antialiasing. This is true regardless of whether the
-  // rendering mode is accelerated or not. For consistency, we don't want to apply AA in accelerated
-  // canvases but not in unaccelerated canvases.
+  // Enabling MSAA overrides a request to disable antialiasing. This is true
+  // regardless of whether the rendering mode is accelerated or not. For
+  // consistency, we don't want to apply AA in accelerated canvases but not in
+  // unaccelerated canvases.
   if (!msaaSampleCount && document().settings() &&
       !document().settings()->antialiased2dCanvasEnabled())
     m_context->setShouldAntialias(false);
 
   if (m_context)
     setNeedsCompositingUpdate();
 }
 
 void HTMLCanvasElement::notifySurfaceInvalid() {
   if (m_context && m_context->is2d())
@@ skipping 33 matching lines @@
   if (is3D())
     checkedExternallyAllocatedMemory +=
         m_context->externallyAllocatedBytesPerPixel();
 
   checkedExternallyAllocatedMemory *= width();
   checkedExternallyAllocatedMemory *= height();
   intptr_t externallyAllocatedMemory =
       checkedExternallyAllocatedMemory.ValueOrDefault(
           std::numeric_limits<intptr_t>::max());
 
-  // Subtracting two intptr_t that are known to be positive will never underflow.
+  // Subtracting two intptr_t that are known to be positive will never
+  // underflow.
   v8::Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(
       externallyAllocatedMemory - m_externallyAllocatedMemory);
   m_externallyAllocatedMemory = externallyAllocatedMemory;
 }
 
 SkCanvas* HTMLCanvasElement::drawingCanvas() const {
   return buffer() ? m_imageBuffer->canvas() : nullptr;
 }
 
 void HTMLCanvasElement::disableDeferral(DisableDeferralReason reason) const {
@@ skipping 122 matching lines @@
   }
 
   if (!m_context) {
     *status = NormalSourceImageStatus;
     return createTransparentImage(size());
   }
 
   sk_sp<SkImage> skImage;
   if (m_context->is3d()) {
     // Because WebGL sources always require making a copy of the back buffer, we
-    // use paintRenderingResultsToCanvas instead of getImage in order to keep a cached
-    // copy of the backing in the canvas's ImageBuffer.
+    // use paintRenderingResultsToCanvas instead of getImage in order to keep a
+    // cached copy of the backing in the canvas's ImageBuffer.
     renderingContext()->paintRenderingResultsToCanvas(BackBuffer);
     skImage = hasImageBuffer()
                   ? buffer()->newSkImageSnapshot(hint, reason)
                   : createTransparentImage(size())->imageForCurrentFrame();
   } else {
     if (ExpensiveCanvasHeuristicParameters::
             DisableAccelerationToAvoidReadbacks &&
         !RuntimeEnabledFeatures::canvas2dFixedRenderingModeEnabled() &&
         hint == PreferNoAcceleration && m_context->isAccelerated() &&
         hasImageBuffer())
@@ skipping 47 matching lines @@
 
 bool HTMLCanvasElement::isOpaque() const {
   return m_context && !m_context->creationAttributes().alpha();
 }
 
 bool HTMLCanvasElement::isSupportedInteractiveCanvasFallback(
     const Element& element) {
   if (!element.isDescendantOf(this))
     return false;
 
-  // An element is a supported interactive canvas fallback element if it is one of the following:
+  // An element is a supported interactive canvas fallback element if it is one
+  // of the following:
   // https://html.spec.whatwg.org/multipage/scripting.html#supported-interactive-canvas-fallback-element
 
-  // An a element that represents a hyperlink and that does not have any img descendants.
+  // An a element that represents a hyperlink and that does not have any img
+  // descendants.
   if (isHTMLAnchorElement(element))
     return !Traversal<HTMLImageElement>::firstWithin(element);
 
   // A button element
   if (isHTMLButtonElement(element))
     return true;
 
-  // An input element whose type attribute is in one of the Checkbox or Radio Button states.
-  // An input element that is a button but its type attribute is not in the Image Button state.
+  // An input element whose type attribute is in one of the Checkbox or Radio
+  // Button states.  An input element that is a button but its type attribute is
+  // not in the Image Button state.
   if (isHTMLInputElement(element)) {
     const HTMLInputElement& inputElement = toHTMLInputElement(element);
     if (inputElement.type() == InputTypeNames::checkbox ||
         inputElement.type() == InputTypeNames::radio ||
         inputElement.isTextButton())
       return true;
   }
 
-  // A select element with a multiple attribute or a display size greater than 1.
+  // A select element with a "multiple" attribute or with a display size greater
+  // than 1.
   if (isHTMLSelectElement(element)) {
     const HTMLSelectElement& selectElement = toHTMLSelectElement(element);
     if (selectElement.multiple() || selectElement.size() > 1)
       return true;
   }
 
-  // An option element that is in a list of options of a select element with a multiple attribute or a display size greater than 1.
+  // An option element that is in a list of options of a select element with a
+  // "multiple" attribute or with a display size greater than 1.
   if (isHTMLOptionElement(element) && element.parentNode() &&
       isHTMLSelectElement(*element.parentNode())) {
     const HTMLSelectElement& selectElement =
         toHTMLSelectElement(*element.parentNode());
     if (selectElement.multiple() || selectElement.size() > 1)
       return true;
   }
 
-  // An element that would not be interactive content except for having the tabindex attribute specified.
+  // An element that would not be interactive content except for having the
+  // tabindex attribute specified.
   if (element.fastHasAttribute(HTMLNames::tabindexAttr))
     return true;
 
-  // A non-interactive table, caption, thead, tbody, tfoot, tr, td, or th element.
+  // A non-interactive table, caption, thead, tbody, tfoot, tr, td, or th
+  // element.
   if (isHTMLTableElement(element) ||
       element.hasTagName(HTMLNames::captionTag) ||
       element.hasTagName(HTMLNames::theadTag) ||
       element.hasTagName(HTMLNames::tbodyTag) ||
       element.hasTagName(HTMLNames::tfootTag) ||
       element.hasTagName(HTMLNames::trTag) ||
       element.hasTagName(HTMLNames::tdTag) ||
       element.hasTagName(HTMLNames::thTag))
     return true;
 
@@ skipping 18 matching lines @@
   mojom::blink::OffscreenCanvasSurfacePtr service;
   Platform::current()->interfaceProvider()->getInterface(
       mojo::GetProxy(&service));
   m_surfaceLayerBridge =
       wrapUnique(new CanvasSurfaceLayerBridge(std::move(service)));
   return m_surfaceLayerBridge->createSurfaceLayer(this->width(),
                                                   this->height());
 }
 
 }  // namespace blink