Remove unneeded abstractions and simplify RecordingImageBufferSurface

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 870 matching lines @@
     // resource limits. So we need to keep the number of texture resources
     // under tight control
     if (ImageBuffer::GetGlobalAcceleratedImageBufferCount() >=
         kMaxGlobalAcceleratedImageBufferCount)
       return false;
   }
 
   return true;
 }
 
-namespace {
-
-class UnacceleratedSurfaceFactory
-    : public RecordingImageBufferFallbackSurfaceFactory {
- public:
-  virtual std::unique_ptr<ImageBufferSurface> CreateSurface(
-      const IntSize& size,
-      OpacityMode opacity_mode,
-      const CanvasColorParams& color_params) {
-    return WTF::WrapUnique(new UnacceleratedImageBufferSurface(
-        size, opacity_mode, kInitializeImagePixels, color_params));
-  }
-
-  virtual ~UnacceleratedSurfaceFactory() {}
-};
-
-}  // namespace
-
 bool HTMLCanvasElement::ShouldUseDisplayList() {
   // Rasterization of web contents will blend in the output space. Only embed
   // the canvas as a display list if it intended to do output space blending as
   // well.
   if (!context_->color_params().UsesOutputSpaceBlending())
     return false;
 
   if (RuntimeEnabledFeatures::forceDisplayList2dCanvasEnabled())
     return true;
 
   if (!RuntimeEnabledFeatures::displayList2dCanvasEnabled())
     return false;
 
   return true;
 }
 
 std::unique_ptr<ImageBufferSurface>
 HTMLCanvasElement::CreateWebGLImageBufferSurface(OpacityMode opacity_mode) {
   DCHECK(Is3d());
   // If 3d, but the use of the canvas will be for non-accelerated content
   // then make a non-accelerated ImageBuffer. This means copying the internal
   // Image will require a pixel readback, but that is unavoidable in this case.
-  auto surface = WTF::WrapUnique(new AcceleratedImageBufferSurface(
-      size(), opacity_mode, context_->color_params()));
+  auto surface = WTF::MakeUnique<AcceleratedImageBufferSurface>(
+      size(), opacity_mode, context_->color_params());
   if (surface->IsValid())
     return std::move(surface);
   return nullptr;
 }
 
 std::unique_ptr<ImageBufferSurface>
 HTMLCanvasElement::CreateAcceleratedImageBufferSurface(OpacityMode opacity_mode,
                                                        int* msaa_sample_count) {
   if (GetDocument().GetSettings()) {
     *msaa_sample_count =
         GetDocument().GetSettings()->GetAccelerated2dCanvasMSAASampleCount();
   }
 
   // Avoid creating |contextProvider| until we're sure we want to try use it,
   // since it costs us GPU memory.
   std::unique_ptr<WebGraphicsContext3DProvider> context_provider(
       Platform::Current()->CreateSharedOffscreenGraphicsContext3DProvider());
   if (!context_provider) {
     CanvasMetrics::CountCanvasContextUsage(
         CanvasMetrics::kAccelerated2DCanvasGPUContextLost);
     return nullptr;
   }
 
   if (context_provider->IsSoftwareRendering())
     return nullptr;  // Don't use accelerated canvas with swiftshader.
 
-  std::unique_ptr<ImageBufferSurface> surface =
-      WTF::WrapUnique(new Canvas2DImageBufferSurface(
-          std::move(context_provider), size(), *msaa_sample_count, opacity_mode,
-          Canvas2DLayerBridge::kEnableAcceleration, context_->color_params()));
+  auto surface = WTF::MakeUnique<Canvas2DImageBufferSurface>(
+      std::move(context_provider), size(), *msaa_sample_count, opacity_mode,
+      Canvas2DLayerBridge::kEnableAcceleration, context_->color_params());
   if (!surface->IsValid()) {
     CanvasMetrics::CountCanvasContextUsage(
         CanvasMetrics::kGPUAccelerated2DCanvasImageBufferCreationFailed);
     return nullptr;
   }
 
   CanvasMetrics::CountCanvasContextUsage(
       CanvasMetrics::kGPUAccelerated2DCanvasImageBufferCreated);
-  return surface;
+  return std::move(surface);
 }
 
 std::unique_ptr<ImageBufferSurface>
 HTMLCanvasElement::CreateUnacceleratedImageBufferSurface(
     OpacityMode opacity_mode) {
   if (ShouldUseDisplayList()) {
-    auto surface = WTF::WrapUnique(new RecordingImageBufferSurface(
-        size(), WTF::WrapUnique(new UnacceleratedSurfaceFactory), opacity_mode,
-        context_->color_params()));
+    auto surface = WTF::MakeUnique<RecordingImageBufferSurface>(
+        size(), opacity_mode, context_->color_params());
     if (surface->IsValid()) {
       CanvasMetrics::CountCanvasContextUsage(
           CanvasMetrics::kDisplayList2DCanvasImageBufferCreated);
       return std::move(surface);
     }
     // We fallback to a non-display-list surface without recording a metric
     // here.
   }
 
-  auto surface_factory = WTF::MakeUnique<UnacceleratedSurfaceFactory>();
-  auto surface = surface_factory->CreateSurface(size(), opacity_mode,
-                                                context_->color_params());
+  auto surface = WTF::MakeUnique<UnacceleratedImageBufferSurface>(
+      size(), opacity_mode, kInitializeImagePixels, context_->color_params());
   if (surface->IsValid()) {
     CanvasMetrics::CountCanvasContextUsage(
         CanvasMetrics::kUnaccelerated2DCanvasImageBufferCreated);
-    return surface;
+    return std::move(surface);
   }
 
   CanvasMetrics::CountCanvasContextUsage(
       CanvasMetrics::kUnaccelerated2DCanvasImageBufferCreationFailed);
   return nullptr;
 }
 
 void HTMLCanvasElement::CreateImageBuffer() {
   CreateImageBufferInternal(nullptr);
   if (did_fail_to_create_image_buffer_ && Is2d() && !size().IsEmpty())
@@ skipping 465 matching lines @@
   DCHECK(!surface_layer_bridge_);
   LocalFrame* frame = GetDocument().GetFrame();
   WebLayerTreeView* layer_tree_view = nullptr;
   // TODO(xlai): Ensure OffscreenCanvas commit() is still functional when a
   // frame-less HTML canvas's document is reparenting under another frame.
   // See crbug.com/683172.
   if (frame) {
     layer_tree_view =
         frame->GetPage()->GetChromeClient().GetWebLayerTreeView(frame);
     surface_layer_bridge_ =
-        WTF::WrapUnique(new CanvasSurfaceLayerBridge(this, layer_tree_view));
+        WTF::MakeUnique<CanvasSurfaceLayerBridge>(this, layer_tree_view);
     // Creates a placeholder layer first before Surface is created.
     surface_layer_bridge_->CreateSolidColorLayer();
   }
 }
 
 void HTMLCanvasElement::OnWebLayerReplaced() {
   SetNeedsCompositingUpdate();
 }
 
 }  // namespace blink