Removing canvas rendering mode switching feature

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 49 matching lines @@
 #include "core/layout/LayoutHTMLCanvas.h"
 #include "core/layout/api/LayoutViewItem.h"
 #include "core/layout/compositing/PaintLayerCompositor.h"
 #include "core/page/ChromeClient.h"
 #include "core/paint/PaintLayer.h"
 #include "core/paint/PaintTiming.h"
 #include "core/probe/CoreProbes.h"
 #include "platform/Histogram.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/graphics/Canvas2DImageBufferSurface.h"
+#include "platform/graphics/CanvasHeuristicParameters.h"
 #include "platform/graphics/CanvasMetrics.h"
-#include "platform/graphics/ExpensiveCanvasHeuristicParameters.h"
 #include "platform/graphics/ImageBuffer.h"
 #include "platform/graphics/RecordingImageBufferSurface.h"
 #include "platform/graphics/StaticBitmapImage.h"
 #include "platform/graphics/UnacceleratedImageBufferSurface.h"
 #include "platform/graphics/gpu/AcceleratedImageBufferSurface.h"
 #include "platform/graphics/gpu/SharedGpuContext.h"
 #include "platform/graphics/paint/PaintCanvas.h"
 #include "platform/image-encoders/ImageEncoderUtils.h"
 #include "platform/transforms/AffineTransform.h"
 #include "platform/wtf/CheckedNumeric.h"
@@ skipping 53 matching lines @@
 inline HTMLCanvasElement::HTMLCanvasElement(Document& document)
     : HTMLElement(canvasTag, document),
       ContextLifecycleObserver(&document),
       PageVisibilityObserver(document.GetPage()),
       size_(kDefaultWidth, kDefaultHeight),
       context_(this, nullptr),
       ignore_reset_(false),
       externally_allocated_memory_(0),
       origin_clean_(true),
       did_fail_to_create_image_buffer_(false),
-      image_buffer_is_clear_(false),
-      num_frames_since_last_rendering_mode_switch_(0),
-      pending_rendering_mode_switch_(false) {
+      image_buffer_is_clear_(false) {
   CanvasMetrics::CountCanvasContextUsage(CanvasMetrics::kCanvasCreated);
   UseCounter::Count(document, UseCounter::kHTMLCanvasElement);
 }
 
 DEFINE_NODE_FACTORY(HTMLCanvasElement)
 
 HTMLCanvasElement::~HTMLCanvasElement() {
   v8::Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(
       -externally_allocated_memory_);
 }
@@ skipping 264 matching lines @@
     dirty_rect_.Intersect(src_rect);
     LayoutRect mapped_dirty_rect(EnclosingIntRect(
         MapRect(dirty_rect_, src_rect, FloatRect(ro->ContentBoxRect()))));
     // For querying PaintLayer::compositingState()
     // FIXME: is this invalidation using the correct compositing state?
     DisableCompositingQueryAsserts disabler;
     ro->InvalidatePaintRectangle(mapped_dirty_rect);
   }
   dirty_rect_ = FloatRect();
 
-  num_frames_since_last_rendering_mode_switch_++;
-  if (RuntimeEnabledFeatures::
-          enableCanvas2dDynamicRenderingModeSwitchingEnabled() &&
-      !RuntimeEnabledFeatures::canvas2dFixedRenderingModeEnabled()) {
-    if (Is2d() && GetImageBuffer() && GetImageBuffer()->IsAccelerated() &&
-        num_frames_since_last_rendering_mode_switch_ >=
-            ExpensiveCanvasHeuristicParameters::kMinFramesBeforeSwitch &&
-        !pending_rendering_mode_switch_) {
-      if (!context_->IsAccelerationOptimalForCanvasContent()) {
-        // 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();
-                  }
-                },
-                image_buffer_->weak_ptr_factory_.CreateWeakPtr()));
-        num_frames_since_last_rendering_mode_switch_ = 0;
-        pending_rendering_mode_switch_ = true;
-      }
-    }
-  }
-
-  if (pending_rendering_mode_switch_ && GetOrCreateImageBuffer() &&
-      !GetOrCreateImageBuffer()->IsAccelerated()) {
-    pending_rendering_mode_switch_ = false;
-  }
-
   DCHECK(dirty_rect_.IsEmpty());
 }
 
 void HTMLCanvasElement::Reset() {
   if (ignore_reset_)
     return;
 
   dirty_rect_ = FloatRect();
 
   bool ok;
@@ skipping 378 matching lines @@
 #if 0
         // TODO(junov): re-enable this code once we solve the problem of recording
         // GPU-backed images to a PaintRecord for cross-context rendering crbug.com/490328
 
         // If the compositor provides GPU acceleration to display list canvases, we
         // prefer that over direct acceleration.
         if (document().viewportDescription().matchesHeuristicsForGpuRasterization())
             return false;
 #endif
     // If the GPU resources would be very expensive, prefer a display list.
-    if (canvas_pixel_count > ExpensiveCanvasHeuristicParameters::
-                                 kPreferDisplayListOverGpuSizeThreshold)
+    if (canvas_pixel_count >
+        CanvasHeuristicParameters::kPreferDisplayListOverGpuSizeThreshold)
       return false;
   }
 
   // Do not use acceleration for small canvas.
   if (criteria != kIgnoreResourceLimitCriteria) {
     Settings* settings = GetDocument().GetSettings();
     if (!settings ||
         canvas_pixel_count < settings->GetMinimumAccelerated2dCanvasSize())
       return false;
 
@@ skipping 345 matching lines @@
     context_->StyleDidChange(old_style, new_style);
 }
 
 void HTMLCanvasElement::DidMoveToNewDocument(Document& old_document) {
   ContextLifecycleObserver::SetContext(&GetDocument());
   PageVisibilityObserver::SetContext(GetDocument().GetPage());
   HTMLElement::DidMoveToNewDocument(old_document);
 }
 
 void HTMLCanvasElement::WillDrawImageTo2DContext(CanvasImageSource* source) {
-  if (ExpensiveCanvasHeuristicParameters::kEnableAccelerationToAvoidReadbacks &&
+  if (CanvasHeuristicParameters::kEnableAccelerationToAvoidReadbacks &&
       SharedGpuContext::AllowSoftwareToAcceleratedCanvasUpgrade() &&
       source->IsAccelerated() && !GetOrCreateImageBuffer()->IsAccelerated() &&
       ShouldAccelerate(kIgnoreResourceLimitCriteria)) {
     OpacityMode opacity_mode =
         context_->CreationAttributes().alpha() ? kNonOpaque : kOpaque;
     int msaa_sample_count = 0;
     std::unique_ptr<ImageBufferSurface> surface =
         CreateAcceleratedImageBufferSurface(opacity_mode, &msaa_sample_count);
     if (surface) {
       GetOrCreateImageBuffer()->SetSurface(std::move(surface));
@@ skipping 41 matching lines @@
     // 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.
     RenderingContext()->PaintRenderingResultsToCanvas(kBackBuffer);
     if (GetImageBuffer()) {
       sk_image = GetImageBuffer()->NewSkImageSnapshot(hint, reason);
     } else {
       sk_image = CreateTransparentSkImage(Size());
     }
   } else {
-    if (ExpensiveCanvasHeuristicParameters::
-            kDisableAccelerationToAvoidReadbacks &&
+    if (CanvasHeuristicParameters::kDisableAccelerationToAvoidReadbacks &&
         !RuntimeEnabledFeatures::canvas2dFixedRenderingModeEnabled() &&
         hint == kPreferNoAcceleration && GetImageBuffer() &&
         GetImageBuffer()->IsAccelerated()) {
       GetImageBuffer()->DisableAcceleration();
     }
     RefPtr<Image> image = RenderingContext()->GetImage(hint, reason);
     if (image) {
       sk_image = image->ImageForCurrentFrame();
     } else {
       sk_image = CreateTransparentSkImage(Size());
@@ skipping 162 matching lines @@
     // Creates a placeholder layer first before Surface is created.
     surface_layer_bridge_->CreateSolidColorLayer();
   }
 }
 
 void HTMLCanvasElement::OnWebLayerReplaced() {
   SetNeedsCompositingUpdate();
 }
 
 }  // namespace blink