Refactor Canvas2DLayerBridge

In our current implementation, we have a Canvas2DImageBufferSurface that
inherits from ImageBufferSurface. The Canvas2DImageBufferSurface keeps
a RefPtr to Canvas2DLayerBridge, and pretty much all the functions in
Canvas2DImageBufferSurface directly calls the functions in Canvas2DLayerBridge.
The reason for this design is that Canvas2DLayerBridge is a RefCounted
class, so that the MailboxInfo could keep a pointer to Canvas2DLayerBridge.

This CL does a refactor in a way that makes Canvas2DLayerBridge directly
inherits from ImageBufferSurface.

Bug: None
Cq-Include-Trybots: master.tryserver.chromium.linux:linux_layout_tests_slimming_paint_v2
Change-Id: Iceaff82d7561f1d064a0e2cc546f47098dd8e110
Reviewed-on: https://chromium-review.googlesource.com/576994Reviewed-by: Justin Novosad <junov@chromium.org>
Commit-Queue: Xida Chen <xidachen@chromium.org>
Cr-Commit-Position: refs/heads/master@{#491827}

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

@@ -68,7 +68,6 @@
 #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/ImageBuffer.h"
@@ -930,7 +929,7 @@ HTMLCanvasElement::CreateAcceleratedImageBufferSurface(OpacityMode opacity_mode,
   if (context_provider_wrapper->ContextProvider()->IsSoftwareRendering())
     return nullptr;  // Don't use accelerated canvas with swiftshader.
 
-  auto surface = WTF::MakeUnique<Canvas2DImageBufferSurface>(
+  auto surface = WTF::MakeUnique<Canvas2DLayerBridge>(
       Size(), *msaa_sample_count, opacity_mode,
       Canvas2DLayerBridge::kEnableAcceleration, GetCanvasColorParams());
   if (!surface->IsValid()) {

third_party/WebKit/Source/core/paint/HTMLCanvasPainterTest.cpp

@@ -12,7 +12,6 @@
 #include "core/loader/EmptyClients.h"
 #include "core/paint/StubChromeClientForSPv2.h"
 #include "core/testing/DummyPageHolder.h"
-#include "platform/graphics/Canvas2DImageBufferSurface.h"
 #include "platform/graphics/Canvas2DLayerBridge.h"
 #include "platform/graphics/WebGraphicsContext3DProviderWrapper.h"
 #include "platform/graphics/gpu/SharedGpuContext.h"
@@ -66,8 +65,9 @@ class HTMLCanvasPainterTestForSPv2 : public ::testing::Test,
     return chrome_client_->HasLayer(layer);
   }
 
-  RefPtr<Canvas2DLayerBridge> MakeCanvas2DLayerBridge(const IntSize& size) {
-    return AdoptRef(new Canvas2DLayerBridge(
+  std::unique_ptr<Canvas2DLayerBridge> MakeCanvas2DLayerBridge(
+      const IntSize& size) {
+    return WTF::WrapUnique(new Canvas2DLayerBridge(
         size, 0, kNonOpaque, Canvas2DLayerBridge::kForceAccelerationForTesting,
         CanvasColorParams()));
   }
@@ -89,10 +89,9 @@ TEST_P(HTMLCanvasPainterTestForSPv2, Canvas2DLayerAppearsInLayerTree) {
   attributes.setAlpha(true);
   CanvasRenderingContext* context =
       element->GetCanvasRenderingContext("2d", attributes);
-  RefPtr<Canvas2DLayerBridge> bridge =
+  std::unique_ptr<Canvas2DLayerBridge> bridge =
       MakeCanvas2DLayerBridge(IntSize(300, 200));
-  element->CreateImageBufferUsingSurfaceForTesting(WTF::WrapUnique(
-      new Canvas2DImageBufferSurface(bridge, IntSize(300, 200))));
+  element->CreateImageBufferUsingSurfaceForTesting(std::move(bridge));
   ASSERT_EQ(context, element->RenderingContext());
   ASSERT_TRUE(context->IsComposited());
   ASSERT_TRUE(element->IsAccelerated());

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

@@ -21,7 +21,6 @@
 #include "modules/canvas2d/CanvasGradient.h"
 #include "modules/canvas2d/CanvasPattern.h"
 #include "modules/webgl/WebGLRenderingContext.h"
-#include "platform/graphics/Canvas2DImageBufferSurface.h"
 #include "platform/graphics/CanvasHeuristicParameters.h"
 #include "platform/graphics/RecordingImageBufferSurface.h"
 #include "platform/graphics/StaticBitmapImage.h"
@@ -129,7 +128,7 @@ class CanvasRenderingContext2DTest : public ::testing::Test {
 
   void TearDown() override;
   void UnrefCanvas();
-  PassRefPtr<Canvas2DLayerBridge> MakeBridge(
+  std::unique_ptr<Canvas2DLayerBridge> MakeBridge(
       const IntSize&,
       Canvas2DLayerBridge::AccelerationMode);
 
@@ -247,10 +246,10 @@ void CanvasRenderingContext2DTest::TearDown() {
   SharedGpuContext::SetContextProviderFactoryForTesting(nullptr);
 }
 
-PassRefPtr<Canvas2DLayerBridge> CanvasRenderingContext2DTest::MakeBridge(
+std::unique_ptr<Canvas2DLayerBridge> CanvasRenderingContext2DTest::MakeBridge(
     const IntSize& size,
     Canvas2DLayerBridge::AccelerationMode acceleration_mode) {
-  return AdoptRef(new Canvas2DLayerBridge(
+  return WTF::WrapUnique(new Canvas2DLayerBridge(
       size, 0, kNonOpaque, acceleration_mode, CanvasColorParams()));
 }
 
@@ -931,11 +930,9 @@ TEST_F(CanvasRenderingContext2DTest, MAYBE_GetImageDataDisablesAcceleration) {
 
   CreateContext(kNonOpaque);
   IntSize size(300, 300);
-  RefPtr<Canvas2DLayerBridge> bridge =
+  std::unique_ptr<Canvas2DLayerBridge> bridge =
       MakeBridge(size, Canvas2DLayerBridge::kEnableAcceleration);
-  std::unique_ptr<Canvas2DImageBufferSurface> surface(
-      new Canvas2DImageBufferSurface(bridge, size));
-  CanvasElement().CreateImageBufferUsingSurfaceForTesting(std::move(surface));
+  CanvasElement().CreateImageBufferUsingSurfaceForTesting(std::move(bridge));
 
   EXPECT_TRUE(CanvasElement().GetImageBuffer()->IsAccelerated());
   EXPECT_EQ(1u, GetGlobalAcceleratedImageBufferCount());
@@ -1000,11 +997,9 @@ TEST_F(CanvasRenderingContext2DTest, TextureUploadHeuristics) {
 
     CreateContext(kNonOpaque);
     IntSize size(dst_size, dst_size);
-    RefPtr<Canvas2DLayerBridge> bridge =
+    std::unique_ptr<Canvas2DLayerBridge> bridge =
         MakeBridge(size, Canvas2DLayerBridge::kEnableAcceleration);
-    std::unique_ptr<Canvas2DImageBufferSurface> surface(
-        new Canvas2DImageBufferSurface(bridge, size));
-    CanvasElement().CreateImageBufferUsingSurfaceForTesting(std::move(surface));
+    CanvasElement().CreateImageBufferUsingSurfaceForTesting(std::move(bridge));
 
     EXPECT_TRUE(CanvasElement().GetImageBuffer()->IsAccelerated());
     EXPECT_EQ(1u, GetGlobalAcceleratedImageBufferCount());
@@ -1532,13 +1527,11 @@ TEST_F(CanvasRenderingContext2DTestWithTestingPlatform,
        ElementRequestsCompositingUpdateOnHibernateAndWakeUp) {
   CreateContext(kNonOpaque);
   IntSize size(300, 300);
-  RefPtr<Canvas2DLayerBridge> bridge =
+  std::unique_ptr<Canvas2DLayerBridge> bridge =
       MakeBridge(size, Canvas2DLayerBridge::kEnableAcceleration);
   // Force hibernatation to occur in an immediate task.
   bridge->DontUseIdleSchedulingForTesting();
-  std::unique_ptr<Canvas2DImageBufferSurface> surface(
-      new Canvas2DImageBufferSurface(bridge, size));
-  CanvasElement().CreateImageBufferUsingSurfaceForTesting(std::move(surface));
+  CanvasElement().CreateImageBufferUsingSurfaceForTesting(std::move(bridge));
 
   EXPECT_TRUE(CanvasElement().GetImageBuffer()->IsAccelerated());
 

third_party/WebKit/Source/platform/BUILD.gn

@@ -848,7 +848,6 @@ component("platform") {
     "graphics/BitmapImageMetrics.h",
     "graphics/BoxReflection.cpp",
     "graphics/BoxReflection.h",
-    "graphics/Canvas2DImageBufferSurface.h",
     "graphics/Canvas2DLayerBridge.cpp",
     "graphics/Canvas2DLayerBridge.h",
     "graphics/CanvasColorParams.cpp",

third_party/WebKit/Source/platform/graphics/Canvas2DImageBufferSurface.h

-/*
- * Copyright (C) 2013 Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *     * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef Canvas2DImageBufferSurface_h
-#define Canvas2DImageBufferSurface_h
-
-#include "platform/graphics/Canvas2DLayerBridge.h"
-#include "platform/graphics/ImageBufferSurface.h"
-#include "platform/graphics/StaticBitmapImage.h"
-#include "third_party/skia/include/core/SkRefCnt.h"
-
-namespace blink {
-
-// This shim is necessary because ImageBufferSurfaces are not allowed to be
-// RefCounted.
-class Canvas2DImageBufferSurface final : public ImageBufferSurface {
- public:
-  Canvas2DImageBufferSurface(
-      const IntSize& size,
-      int msaa_sample_count,
-      OpacityMode opacity_mode,
-      Canvas2DLayerBridge::AccelerationMode acceleration_mode,
-      const CanvasColorParams& color_params)
-      : ImageBufferSurface(size, opacity_mode, color_params),
-        layer_bridge_(AdoptRef(new Canvas2DLayerBridge(size,
-                                                       msaa_sample_count,
-                                                       opacity_mode,
-                                                       acceleration_mode,
-                                                       color_params))) {
-    Init();
-  }
-
-  Canvas2DImageBufferSurface(PassRefPtr<Canvas2DLayerBridge> bridge,
-                             const IntSize& size)
-      : ImageBufferSurface(size,
-                           bridge->GetOpacityMode(),
-                           bridge->color_params()),
-        layer_bridge_(std::move(bridge)) {
-    Init();
-  }
-
-  ~Canvas2DImageBufferSurface() override { layer_bridge_->BeginDestruction(); }
-
-  // ImageBufferSurface implementation
-  void FinalizeFrame() override { layer_bridge_->FinalizeFrame(); }
-  void DoPaintInvalidation(const FloatRect& dirty_rect) override {
-    layer_bridge_->DoPaintInvalidation(dirty_rect);
-  }
-  void WillOverwriteCanvas() override { layer_bridge_->WillOverwriteCanvas(); }
-  PaintCanvas* Canvas() override { return layer_bridge_->Canvas(); }
-  void DisableDeferral(DisableDeferralReason reason) override {
-    layer_bridge_->DisableDeferral(reason);
-  }
-  bool IsValid() const override { return layer_bridge_->CheckSurfaceValid(); }
-  bool Restore() override { return layer_bridge_->RestoreSurface(); }
-  WebLayer* Layer() const override { return layer_bridge_->Layer(); }
-  bool IsAccelerated() const override { return layer_bridge_->IsAccelerated(); }
-  void SetFilterQuality(SkFilterQuality filter_quality) override {
-    layer_bridge_->SetFilterQuality(filter_quality);
-  }
-  void SetIsHidden(bool hidden) override { layer_bridge_->SetIsHidden(hidden); }
-  void SetImageBuffer(ImageBuffer* image_buffer) override {
-    layer_bridge_->SetImageBuffer(image_buffer);
-  }
-  void DidDraw(const FloatRect& rect) override { layer_bridge_->DidDraw(rect); }
-  void Flush(FlushReason) override { layer_bridge_->Flush(); }
-  void FlushGpu(FlushReason) override { layer_bridge_->FlushGpu(); }
-  bool WritePixels(const SkImageInfo& orig_info,
-                   const void* pixels,
-                   size_t row_bytes,
-                   int x,
-                   int y) override {
-    return layer_bridge_->WritePixels(orig_info, pixels, row_bytes, x, y);
-  }
-
-  RefPtr<StaticBitmapImage> NewImageSnapshot(AccelerationHint hint,
-                                             SnapshotReason reason) override {
-    return layer_bridge_->NewImageSnapshot(hint, reason);
-  }
-
- private:
-  void Init() {
-    Clear();
-    if (IsValid())
-      layer_bridge_->Flush();
-  }
-
-  RefPtr<Canvas2DLayerBridge> layer_bridge_;
-};
-
-}  // namespace blink
-
-#endif

third_party/WebKit/Source/platform/graphics/Canvas2DLayerBridge.cpp

@@ -198,8 +198,10 @@ Canvas2DLayerBridge::Canvas2DLayerBridge(const IntSize& size,
                                          int msaa_sample_count,
                                          OpacityMode opacity_mode,
                                          AccelerationMode acceleration_mode,
-                                         const CanvasColorParams& color_params)
-    : context_provider_wrapper_(SharedGpuContext::ContextProviderWrapper()),
+                                         const CanvasColorParams& color_params,
+                                         bool is_unit_test)
+    : ImageBufferSurface(size, opacity_mode, color_params),
+      context_provider_wrapper_(SharedGpuContext::ContextProviderWrapper()),
       logger_(WTF::WrapUnique(new Logger)),
       weak_ptr_factory_(this),
       image_buffer_(0),
@@ -224,9 +226,12 @@ Canvas2DLayerBridge::Canvas2DLayerBridge(const IntSize& size,
   TRACE_EVENT_INSTANT0("test_gpu", "Canvas2DLayerBridgeCreation",
                        TRACE_EVENT_SCOPE_GLOBAL);
   StartRecording();
+  if (!is_unit_test)
+    Init();
 }
 
 Canvas2DLayerBridge::~Canvas2DLayerBridge() {
+  BeginDestruction();
   DCHECK(destruction_in_progress_);
 #if USE_IOSURFACE_FOR_2D_CANVAS
   ClearCHROMIUMImageCache();
@@ -234,6 +239,12 @@ Canvas2DLayerBridge::~Canvas2DLayerBridge() {
   layer_.reset();
 }
 
+void Canvas2DLayerBridge::Init() {
+  Clear();
+  if (CheckSurfaceValid())
+    FlushInternal();
+}
+
 void Canvas2DLayerBridge::StartRecording() {
   DCHECK(is_deferral_enabled_);
   recorder_ = WTF::WrapUnique(new PaintRecorder);
@@ -535,7 +546,7 @@ void Canvas2DLayerBridge::Hibernate() {
     return;
   }
 
-  if (!CheckSurfaceValid()) {
+  if (!IsValid()) {
     logger_->ReportHibernationEvent(kHibernationAbortedDueGpuContextLoss);
     return;
   }
@@ -800,7 +811,7 @@ bool Canvas2DLayerBridge::WritePixels(const SkImageInfo& orig_info,
       y + orig_info.height() >= size_.Height()) {
     SkipQueuedDrawCommands();
   } else {
-    Flush();
+    FlushInternal();
   }
   DCHECK(!have_recorded_draw_commands_);
   // call write pixels on the surface, not the recording canvas.
@@ -848,7 +859,7 @@ void Canvas2DLayerBridge::FlushRecordingOnly() {
   }
 }
 
-void Canvas2DLayerBridge::Flush() {
+void Canvas2DLayerBridge::FlushInternal() {
   if (!did_draw_since_last_flush_)
     return;
   TRACE_EVENT0("cc", "Canvas2DLayerBridge::flush");
@@ -859,8 +870,12 @@ void Canvas2DLayerBridge::Flush() {
   did_draw_since_last_flush_ = false;
 }
 
-void Canvas2DLayerBridge::FlushGpu() {
-  Flush();
+void Canvas2DLayerBridge::Flush(FlushReason reason) {
+  FlushInternal();
+}
+
+void Canvas2DLayerBridge::FlushGpuInternal() {
+  FlushInternal();
   gpu::gles2::GLES2Interface* gl = ContextGL();
   if (IsAccelerated() && gl && did_draw_since_last_gpu_flush_) {
     TRACE_EVENT0("cc", "Canvas2DLayerBridge::flushGpu");
@@ -869,6 +884,10 @@ void Canvas2DLayerBridge::FlushGpu() {
   }
 }
 
+void Canvas2DLayerBridge::FlushGpu(FlushReason reason) {
+  FlushGpuInternal();
+}
+
 gpu::gles2::GLES2Interface* Canvas2DLayerBridge::ContextGL() {
   // Check on m_layer is necessary because contextGL() may be called during
   // the destruction of m_layer
@@ -876,7 +895,7 @@ gpu::gles2::GLES2Interface* Canvas2DLayerBridge::ContextGL() {
       !destruction_in_progress_) {
     // Call checkSurfaceValid to ensure the rate limiter is disabled if the
     // context is lost.
-    if (!CheckSurfaceValid())
+    if (!IsValid())
       return nullptr;
   }
   return context_provider_wrapper_
@@ -884,6 +903,10 @@ gpu::gles2::GLES2Interface* Canvas2DLayerBridge::ContextGL() {
              : nullptr;
 }
 
+bool Canvas2DLayerBridge::IsValid() const {
+  return const_cast<Canvas2DLayerBridge*>(this)->CheckSurfaceValid();
+}
+
 bool Canvas2DLayerBridge::CheckSurfaceValid() {
   DCHECK(!destruction_in_progress_);
   if (destruction_in_progress_)
@@ -907,7 +930,7 @@ bool Canvas2DLayerBridge::CheckSurfaceValid() {
   return surface_.get();
 }
 
-bool Canvas2DLayerBridge::RestoreSurface() {
+bool Canvas2DLayerBridge::Restore() {
   DCHECK(!destruction_in_progress_);
   if (destruction_in_progress_ || !IsAccelerated())
     return false;
@@ -1093,13 +1116,13 @@ void Canvas2DLayerBridge::FinalizeFrame() {
 
   if (frames_since_last_commit_ >= 2) {
     if (IsAccelerated()) {
-      FlushGpu();
+      FlushGpuInternal();
       if (!rate_limiter_) {
         rate_limiter_ =
             SharedContextRateLimiter::Create(MaxCanvasAnimationBacklog);
       }
     } else {
-      Flush();
+      FlushInternal();
     }
   }
 
@@ -1119,11 +1142,11 @@ RefPtr<StaticBitmapImage> Canvas2DLayerBridge::NewImageSnapshot(
     SnapshotReason) {
   if (IsHibernating())
     return StaticBitmapImage::Create(hibernation_image_);
-  if (!CheckSurfaceValid())
+  if (!IsValid())
     return nullptr;
   if (!GetOrCreateSurface(hint))
     return nullptr;
-  Flush();
+  FlushInternal();
   // A readback operation may alter the texture parameters, which may affect
   // the compositor's behavior. Therefore, we must trigger copy-on-write
   // even though we are not technically writing to the texture, only to its

third_party/WebKit/Source/platform/graphics/Canvas2DLayerBridge.h

@@ -79,7 +79,7 @@ class SharedContextRateLimiter;
 
 class PLATFORM_EXPORT Canvas2DLayerBridge
     : public NON_EXPORTED_BASE(cc::TextureLayerClient),
-      public RefCounted<Canvas2DLayerBridge> {
+      public ImageBufferSurface {
   WTF_MAKE_NONCOPYABLE(Canvas2DLayerBridge);
 
  public:
@@ -93,7 +93,8 @@ class PLATFORM_EXPORT Canvas2DLayerBridge
                       int msaa_sample_count,
                       OpacityMode,
                       AccelerationMode,
-                      const CanvasColorParams&);
+                      const CanvasColorParams&,
+                      bool is_unit_test = false);
 
   ~Canvas2DLayerBridge() override;
 
@@ -103,26 +104,26 @@ class PLATFORM_EXPORT Canvas2DLayerBridge
                                  out_release_callback) override;
 
   // ImageBufferSurface implementation
-  void FinalizeFrame();
-  void DoPaintInvalidation(const FloatRect& dirty_rect);
-  void WillOverwriteCanvas();
-  PaintCanvas* Canvas();
-  void DisableDeferral(DisableDeferralReason);
-  bool CheckSurfaceValid();
-  bool RestoreSurface();
-  WebLayer* Layer() const;
-  bool IsAccelerated() const;
-  void SetFilterQuality(SkFilterQuality);
-  void SetIsHidden(bool);
-  void SetImageBuffer(ImageBuffer*);
-  void DidDraw(const FloatRect&);
+  void FinalizeFrame() override;
+  void DoPaintInvalidation(const FloatRect& dirty_rect) override;
+  void WillOverwriteCanvas() override;
+  PaintCanvas* Canvas() override;
+  void DisableDeferral(DisableDeferralReason) override;
+  bool IsValid() const override;
+  bool Restore() override;
+  WebLayer* Layer() const override;
+  bool IsAccelerated() const override;
+  void SetFilterQuality(SkFilterQuality) override;
+  void SetIsHidden(bool) override;
+  void SetImageBuffer(ImageBuffer*) override;
+  void DidDraw(const FloatRect&) override;
   bool WritePixels(const SkImageInfo&,
                    const void* pixels,
                    size_t row_bytes,
                    int x,
-                   int y);
-  void Flush();
-  void FlushGpu();
+                   int y) override;
+  void Flush(FlushReason) override;
+  void FlushGpu(FlushReason) override;
   OpacityMode GetOpacityMode() { return opacity_mode_; }
   void DontUseIdleSchedulingForTesting() {
     dont_use_idle_scheduling_for_testing_ = true;
@@ -168,6 +169,10 @@ class PLATFORM_EXPORT Canvas2DLayerBridge
  private:
   void ResetSurface();
   bool IsHidden() { return is_hidden_; }
+  bool CheckSurfaceValid();
+  void Init();
+  void FlushInternal();
+  void FlushGpuInternal();
 
 #if USE_IOSURFACE_FOR_2D_CANVAS
   // All information associated with a CHROMIUM image.
@@ -177,7 +182,6 @@ class PLATFORM_EXPORT Canvas2DLayerBridge
   struct MailboxInfo {
     gpu::Mailbox mailbox_;
     sk_sp<SkImage> image_;
-    RefPtr<Canvas2DLayerBridge> parent_layer_bridge_;
 
 #if USE_IOSURFACE_FOR_2D_CANVAS
     // If this mailbox wraps an IOSurface-backed texture, the ids of the

third_party/WebKit/Source/platform/graphics/Canvas2DLayerBridgeTest.cpp

@@ -70,7 +70,7 @@ namespace {
 class Canvas2DLayerBridgePtr {
  public:
   Canvas2DLayerBridgePtr() {}
-  Canvas2DLayerBridgePtr(PassRefPtr<Canvas2DLayerBridge> layer_bridge)
+  Canvas2DLayerBridgePtr(std::unique_ptr<Canvas2DLayerBridge> layer_bridge)
       : layer_bridge_(std::move(layer_bridge)) {}
 
   ~Canvas2DLayerBridgePtr() { Clear(); }
@@ -78,20 +78,20 @@ class Canvas2DLayerBridgePtr {
   void Clear() {
     if (layer_bridge_) {
       layer_bridge_->BeginDestruction();
-      layer_bridge_.Clear();
+      layer_bridge_.reset();
     }
   }
 
-  void operator=(PassRefPtr<Canvas2DLayerBridge> layer_bridge) {
+  void operator=(std::unique_ptr<Canvas2DLayerBridge> layer_bridge) {
     DCHECK(!layer_bridge_);
     layer_bridge_ = std::move(layer_bridge);
   }
 
-  Canvas2DLayerBridge* operator->() { return layer_bridge_.Get(); }
-  Canvas2DLayerBridge* Get() { return layer_bridge_.Get(); }
+  Canvas2DLayerBridge* operator->() { return layer_bridge_.get(); }
+  Canvas2DLayerBridge* Get() { return layer_bridge_.get(); }
 
  private:
-  RefPtr<Canvas2DLayerBridge> layer_bridge_;
+  std::unique_ptr<Canvas2DLayerBridge> layer_bridge_;
 };
 
 class FakeGLES2InterfaceWithImageSupport : public FakeGLES2Interface {
@@ -129,11 +129,12 @@ class FakePlatformSupport : public TestingPlatformSupport {
 
 class Canvas2DLayerBridgeTest : public Test {
  public:
-  PassRefPtr<Canvas2DLayerBridge> MakeBridge(
+  std::unique_ptr<Canvas2DLayerBridge> MakeBridge(
       const IntSize& size,
       Canvas2DLayerBridge::AccelerationMode acceleration_mode) {
-    RefPtr<Canvas2DLayerBridge> bridge = AdoptRef(new Canvas2DLayerBridge(
-        size, 0, kNonOpaque, acceleration_mode, CanvasColorParams()));
+    std::unique_ptr<Canvas2DLayerBridge> bridge = WTF::WrapUnique(
+        new Canvas2DLayerBridge(size, 0, kNonOpaque, acceleration_mode,
+                                CanvasColorParams(), IsUnitTest()));
     bridge->DontUseIdleSchedulingForTesting();
     return bridge;
   }
@@ -146,14 +147,16 @@ class Canvas2DLayerBridgeTest : public Test {
   void TearDown() override {
     SharedGpuContext::SetContextProviderFactoryForTesting(nullptr);
   }
+  bool IsUnitTest() { return true; }
 
  protected:
   FakeGLES2InterfaceWithImageSupport gl_;
 
   void FullLifecycleTest() {
-    Canvas2DLayerBridgePtr bridge(AdoptRef(new Canvas2DLayerBridge(
-        IntSize(300, 150), 0, kNonOpaque,
-        Canvas2DLayerBridge::kDisableAcceleration, CanvasColorParams())));
+    Canvas2DLayerBridgePtr bridge(WTF::WrapUnique(
+        new Canvas2DLayerBridge(IntSize(300, 150), 0, kNonOpaque,
+                                Canvas2DLayerBridge::kDisableAcceleration,
+                                CanvasColorParams(), IsUnitTest())));
 
     const GrGLTextureInfo* texture_info =
         skia::GrBackendObjectToGrGLTextureInfo(
@@ -169,20 +172,22 @@ class Canvas2DLayerBridgeTest : public Test {
 
   void FallbackToSoftwareIfContextLost() {
     gl_.SetIsContextLost(true);
-    Canvas2DLayerBridgePtr bridge(AdoptRef(new Canvas2DLayerBridge(
-        IntSize(300, 150), 0, kNonOpaque,
-        Canvas2DLayerBridge::kEnableAcceleration, CanvasColorParams())));
-    EXPECT_TRUE(bridge->CheckSurfaceValid());
+    Canvas2DLayerBridgePtr bridge(WTF::WrapUnique(
+        new Canvas2DLayerBridge(IntSize(300, 150), 0, kNonOpaque,
+                                Canvas2DLayerBridge::kEnableAcceleration,
+                                CanvasColorParams(), IsUnitTest())));
+    EXPECT_TRUE(bridge->IsValid());
     EXPECT_FALSE(bridge->IsAccelerated());
   }
 
   void FallbackToSoftwareOnFailedTextureAlloc() {
     {
       // No fallback case.
-      Canvas2DLayerBridgePtr bridge(AdoptRef(new Canvas2DLayerBridge(
-          IntSize(300, 150), 0, kNonOpaque,
-          Canvas2DLayerBridge::kEnableAcceleration, CanvasColorParams())));
-      EXPECT_TRUE(bridge->CheckSurfaceValid());
+      Canvas2DLayerBridgePtr bridge(WTF::WrapUnique(
+          new Canvas2DLayerBridge(IntSize(300, 150), 0, kNonOpaque,
+                                  Canvas2DLayerBridge::kEnableAcceleration,
+                                  CanvasColorParams(), IsUnitTest())));
+      EXPECT_TRUE(bridge->IsValid());
       EXPECT_TRUE(bridge->IsAccelerated());
       RefPtr<StaticBitmapImage> snapshot = bridge->NewImageSnapshot(
           kPreferAcceleration, kSnapshotReasonUnitTests);
@@ -195,10 +200,11 @@ class Canvas2DLayerBridgeTest : public Test {
       GrContext* gr = SharedGpuContext::ContextProviderWrapper()
                           ->ContextProvider()
                           ->GetGrContext();
-      Canvas2DLayerBridgePtr bridge(AdoptRef(new Canvas2DLayerBridge(
-          IntSize(300, 150), 0, kNonOpaque,
-          Canvas2DLayerBridge::kEnableAcceleration, CanvasColorParams())));
-      EXPECT_TRUE(bridge->CheckSurfaceValid());
+      Canvas2DLayerBridgePtr bridge(WTF::WrapUnique(
+          new Canvas2DLayerBridge(IntSize(300, 150), 0, kNonOpaque,
+                                  Canvas2DLayerBridge::kEnableAcceleration,
+                                  CanvasColorParams(), IsUnitTest())));
+      EXPECT_TRUE(bridge->IsValid());
       EXPECT_TRUE(bridge->IsAccelerated());  // We don't yet know that
                                              // allocation will fail.
       // This will cause SkSurface_Gpu creation to fail without
@@ -212,11 +218,11 @@ class Canvas2DLayerBridgeTest : public Test {
   }
 
   void NoDrawOnContextLostTest() {
-    Canvas2DLayerBridgePtr bridge(AdoptRef(new Canvas2DLayerBridge(
+    Canvas2DLayerBridgePtr bridge(WTF::WrapUnique(new Canvas2DLayerBridge(
         IntSize(300, 150), 0, kNonOpaque,
-        Canvas2DLayerBridge::kForceAccelerationForTesting,
-        CanvasColorParams())));
-    EXPECT_TRUE(bridge->CheckSurfaceValid());
+        Canvas2DLayerBridge::kForceAccelerationForTesting, CanvasColorParams(),
+        IsUnitTest())));
+    EXPECT_TRUE(bridge->IsValid());
     PaintFlags flags;
     uint32_t gen_id = bridge->GetOrCreateSurface()->generationID();
     bridge->Canvas()->drawRect(SkRect::MakeXYWH(0, 0, 1, 1), flags);
@@ -227,18 +233,18 @@ class Canvas2DLayerBridgeTest : public Test {
     EXPECT_EQ(gen_id, bridge->GetOrCreateSurface()->generationID());
     // This results in the internal surface being torn down in response to the
     // context loss.
-    EXPECT_FALSE(bridge->CheckSurfaceValid());
+    EXPECT_FALSE(bridge->IsValid());
     EXPECT_EQ(nullptr, bridge->GetOrCreateSurface());
     // The following passes by not crashing
     bridge->Canvas()->drawRect(SkRect::MakeXYWH(0, 0, 1, 1), flags);
-    bridge->Flush();
+    bridge->Flush(kFlushReasonUnknown);
   }
 
   void PrepareMailboxWhenContextIsLost() {
-    Canvas2DLayerBridgePtr bridge(AdoptRef(new Canvas2DLayerBridge(
+    Canvas2DLayerBridgePtr bridge(WTF::WrapUnique(new Canvas2DLayerBridge(
         IntSize(300, 150), 0, kNonOpaque,
-        Canvas2DLayerBridge::kForceAccelerationForTesting,
-        CanvasColorParams())));
+        Canvas2DLayerBridge::kForceAccelerationForTesting, CanvasColorParams(),
+        IsUnitTest())));
 
     EXPECT_TRUE(bridge->IsAccelerated());
 
@@ -253,23 +259,23 @@ class Canvas2DLayerBridgeTest : public Test {
   }
 
   void PrepareMailboxWhenContextIsLostWithFailedRestore() {
-    Canvas2DLayerBridgePtr bridge(AdoptRef(new Canvas2DLayerBridge(
+    Canvas2DLayerBridgePtr bridge(WTF::WrapUnique(new Canvas2DLayerBridge(
         IntSize(300, 150), 0, kNonOpaque,
-        Canvas2DLayerBridge::kForceAccelerationForTesting,
-        CanvasColorParams())));
+        Canvas2DLayerBridge::kForceAccelerationForTesting, CanvasColorParams(),
+        IsUnitTest())));
 
     bridge->GetOrCreateSurface();
-    EXPECT_TRUE(bridge->CheckSurfaceValid());
+    EXPECT_TRUE(bridge->IsValid());
     // When the context is lost we are not sure if we should still be producing
     // GL frames for the compositor or not, so fail to generate frames.
     gl_.SetIsContextLost(true);
-    EXPECT_FALSE(bridge->CheckSurfaceValid());
+    EXPECT_FALSE(bridge->IsValid());
 
     // Restoration will fail because
     // Platform::createSharedOffscreenGraphicsContext3DProvider() is stubbed
     // in unit tests.  This simulates what would happen when attempting to
     // restore while the GPU process is down.
-    bridge->RestoreSurface();
+    bridge->Restore();
 
     viz::TextureMailbox texture_mailbox;
     std::unique_ptr<viz::SingleReleaseCallback> release_callback;
@@ -282,7 +288,7 @@ class Canvas2DLayerBridgeTest : public Test {
     std::unique_ptr<viz::SingleReleaseCallback> release_callback;
 
     {
-      Canvas2DLayerBridgePtr bridge(AdoptRef(new Canvas2DLayerBridge(
+      Canvas2DLayerBridgePtr bridge(WTF::WrapUnique(new Canvas2DLayerBridge(
           IntSize(300, 150), 0, kNonOpaque,
           Canvas2DLayerBridge::kForceAccelerationForTesting,
           CanvasColorParams())));
@@ -303,10 +309,10 @@ class Canvas2DLayerBridgeTest : public Test {
     // Prepare a mailbox, then report the resource as lost.
     // This test passes by not crashing and not triggering assertions.
     {
-      Canvas2DLayerBridgePtr bridge(AdoptRef(new Canvas2DLayerBridge(
+      Canvas2DLayerBridgePtr bridge(WTF::WrapUnique(new Canvas2DLayerBridge(
           IntSize(300, 150), 0, kNonOpaque,
           Canvas2DLayerBridge::kForceAccelerationForTesting,
-          CanvasColorParams())));
+          CanvasColorParams(), IsUnitTest())));
 
       viz::TextureMailbox texture_mailbox;
       std::unique_ptr<viz::SingleReleaseCallback> release_callback;
@@ -323,10 +329,10 @@ class Canvas2DLayerBridgeTest : public Test {
       std::unique_ptr<viz::SingleReleaseCallback> release_callback;
 
       {
-        Canvas2DLayerBridgePtr bridge(AdoptRef(new Canvas2DLayerBridge(
+        Canvas2DLayerBridgePtr bridge(WTF::WrapUnique(new Canvas2DLayerBridge(
             IntSize(300, 150), 0, kNonOpaque,
             Canvas2DLayerBridge::kForceAccelerationForTesting,
-            CanvasColorParams())));
+            CanvasColorParams(), IsUnitTest())));
         bridge->PrepareTextureMailbox(&texture_mailbox, &release_callback);
         // |bridge| goes out of scope and would normally be destroyed, but
         // object is kept alive by self references.
@@ -343,26 +349,28 @@ class Canvas2DLayerBridgeTest : public Test {
 
   void AccelerationHintTest() {
     {
-      Canvas2DLayerBridgePtr bridge(AdoptRef(new Canvas2DLayerBridge(
-          IntSize(300, 300), 0, kNonOpaque,
-          Canvas2DLayerBridge::kEnableAcceleration, CanvasColorParams())));
+      Canvas2DLayerBridgePtr bridge(WTF::WrapUnique(
+          new Canvas2DLayerBridge(IntSize(300, 300), 0, kNonOpaque,
+                                  Canvas2DLayerBridge::kEnableAcceleration,
+                                  CanvasColorParams(), IsUnitTest())));
       PaintFlags flags;
       bridge->Canvas()->drawRect(SkRect::MakeXYWH(0, 0, 1, 1), flags);
       RefPtr<StaticBitmapImage> image = bridge->NewImageSnapshot(
           kPreferAcceleration, kSnapshotReasonUnitTests);
-      EXPECT_TRUE(bridge->CheckSurfaceValid());
+      EXPECT_TRUE(bridge->IsValid());
       EXPECT_TRUE(bridge->IsAccelerated());
     }
 
     {
-      Canvas2DLayerBridgePtr bridge(AdoptRef(new Canvas2DLayerBridge(
-          IntSize(300, 300), 0, kNonOpaque,
-          Canvas2DLayerBridge::kEnableAcceleration, CanvasColorParams())));
+      Canvas2DLayerBridgePtr bridge(WTF::WrapUnique(
+          new Canvas2DLayerBridge(IntSize(300, 300), 0, kNonOpaque,
+                                  Canvas2DLayerBridge::kEnableAcceleration,
+                                  CanvasColorParams(), IsUnitTest())));
       PaintFlags flags;
       bridge->Canvas()->drawRect(SkRect::MakeXYWH(0, 0, 1, 1), flags);
       RefPtr<StaticBitmapImage> image = bridge->NewImageSnapshot(
           kPreferNoAcceleration, kSnapshotReasonUnitTests);
-      EXPECT_TRUE(bridge->CheckSurfaceValid());
+      EXPECT_TRUE(bridge->IsValid());
       EXPECT_FALSE(bridge->IsAccelerated());
     }
   }
@@ -427,7 +435,7 @@ class MockImageBuffer : public ImageBuffer {
 void DrawSomething(Canvas2DLayerBridgePtr& bridge) {
   bridge->DidDraw(FloatRect(0, 0, 1, 1));
   bridge->FinalizeFrame();
-  bridge->Flush();
+  bridge->Flush(kFlushReasonUnknown);
 }
 
 #if CANVAS2D_HIBERNATION_ENABLED
@@ -437,9 +445,10 @@ TEST_F(Canvas2DLayerBridgeTest, DISABLED_HibernationLifeCycle)
 #endif
 {
   ScopedTestingPlatformSupport<FakePlatformSupport> platform;
-  Canvas2DLayerBridgePtr bridge(AdoptRef(new Canvas2DLayerBridge(
-      IntSize(300, 300), 0, kNonOpaque,
-      Canvas2DLayerBridge::kEnableAcceleration, CanvasColorParams())));
+  Canvas2DLayerBridgePtr bridge(WTF::WrapUnique(
+      new Canvas2DLayerBridge(IntSize(300, 300), 0, kNonOpaque,
+                              Canvas2DLayerBridge::kEnableAcceleration,
+                              CanvasColorParams(), IsUnitTest())));
   bridge->DontUseIdleSchedulingForTesting();
   DrawSomething(bridge);
 
@@ -460,7 +469,7 @@ TEST_F(Canvas2DLayerBridgeTest, DISABLED_HibernationLifeCycle)
   ::testing::Mock::VerifyAndClearExpectations(mock_logger_ptr);
   EXPECT_FALSE(bridge->IsAccelerated());
   EXPECT_TRUE(bridge->IsHibernating());
-  EXPECT_TRUE(bridge->CheckSurfaceValid());
+  EXPECT_TRUE(bridge->IsValid());
 
   // Test exiting hibernation
   EXPECT_CALL(
@@ -472,7 +481,7 @@ TEST_F(Canvas2DLayerBridgeTest, DISABLED_HibernationLifeCycle)
   ::testing::Mock::VerifyAndClearExpectations(mock_logger_ptr);
   EXPECT_TRUE(bridge->IsAccelerated());
   EXPECT_FALSE(bridge->IsHibernating());
-  EXPECT_TRUE(bridge->CheckSurfaceValid());
+  EXPECT_TRUE(bridge->IsValid());
 }
 
 #if CANVAS2D_HIBERNATION_ENABLED
@@ -482,9 +491,10 @@ TEST_F(Canvas2DLayerBridgeTest, DISABLED_HibernationReEntry)
 #endif
 {
   ScopedTestingPlatformSupport<FakePlatformSupport> platform;
-  Canvas2DLayerBridgePtr bridge(AdoptRef(new Canvas2DLayerBridge(
-      IntSize(300, 300), 0, kNonOpaque,
-      Canvas2DLayerBridge::kEnableAcceleration, CanvasColorParams())));
+  Canvas2DLayerBridgePtr bridge(WTF::WrapUnique(
+      new Canvas2DLayerBridge(IntSize(300, 300), 0, kNonOpaque,
+                              Canvas2DLayerBridge::kEnableAcceleration,
+                              CanvasColorParams(), IsUnitTest())));
   bridge->DontUseIdleSchedulingForTesting();
   DrawSomething(bridge);
 
@@ -508,7 +518,7 @@ TEST_F(Canvas2DLayerBridgeTest, DISABLED_HibernationReEntry)
   ::testing::Mock::VerifyAndClearExpectations(mock_logger_ptr);
   EXPECT_FALSE(bridge->IsAccelerated());
   EXPECT_TRUE(bridge->IsHibernating());
-  EXPECT_TRUE(bridge->CheckSurfaceValid());
+  EXPECT_TRUE(bridge->IsValid());
 
   // Test exiting hibernation
   EXPECT_CALL(
@@ -520,7 +530,7 @@ TEST_F(Canvas2DLayerBridgeTest, DISABLED_HibernationReEntry)
   ::testing::Mock::VerifyAndClearExpectations(mock_logger_ptr);
   EXPECT_TRUE(bridge->IsAccelerated());
   EXPECT_FALSE(bridge->IsHibernating());
-  EXPECT_TRUE(bridge->CheckSurfaceValid());
+  EXPECT_TRUE(bridge->IsValid());
 }
 
 #if CANVAS2D_HIBERNATION_ENABLED
@@ -532,9 +542,10 @@ TEST_F(Canvas2DLayerBridgeTest,
 #endif
 {
   ScopedTestingPlatformSupport<FakePlatformSupport> platform;
-  Canvas2DLayerBridgePtr bridge(AdoptRef(new Canvas2DLayerBridge(
-      IntSize(300, 300), 0, kNonOpaque,
-      Canvas2DLayerBridge::kEnableAcceleration, CanvasColorParams())));
+  Canvas2DLayerBridgePtr bridge(WTF::WrapUnique(
+      new Canvas2DLayerBridge(IntSize(300, 300), 0, kNonOpaque,
+                              Canvas2DLayerBridge::kEnableAcceleration,
+                              CanvasColorParams(), IsUnitTest())));
   bridge->DontUseIdleSchedulingForTesting();
   DrawSomething(bridge);
   bridge->DisableDeferral(kDisableDeferralReasonUnknown);
@@ -558,7 +569,7 @@ TEST_F(Canvas2DLayerBridgeTest,
   ::testing::Mock::VerifyAndClearExpectations(&mock_image_buffer);
   EXPECT_FALSE(bridge->IsAccelerated());
   EXPECT_TRUE(bridge->IsHibernating());
-  EXPECT_TRUE(bridge->CheckSurfaceValid());
+  EXPECT_TRUE(bridge->IsValid());
 
   // Test exiting hibernation
   EXPECT_CALL(
@@ -571,7 +582,7 @@ TEST_F(Canvas2DLayerBridgeTest,
   ::testing::Mock::VerifyAndClearExpectations(&mock_image_buffer);
   EXPECT_TRUE(bridge->IsAccelerated());
   EXPECT_FALSE(bridge->IsHibernating());
-  EXPECT_TRUE(bridge->CheckSurfaceValid());
+  EXPECT_TRUE(bridge->IsValid());
 }
 
 #if CANVAS2D_HIBERNATION_ENABLED && CANVAS2D_BACKGROUND_RENDER_SWITCH_TO_CPU
@@ -581,9 +592,10 @@ TEST_F(Canvas2DLayerBridgeTest, DISABLED_BackgroundRenderingWhileHibernating)
 #endif
 {
   ScopedTestingPlatformSupport<FakePlatformSupport> platform;
-  Canvas2DLayerBridgePtr bridge(AdoptRef(new Canvas2DLayerBridge(
-      IntSize(300, 300), 0, kNonOpaque,
-      Canvas2DLayerBridge::kEnableAcceleration, CanvasColorParams())));
+  Canvas2DLayerBridgePtr bridge(WTF::WrapUnique(
+      new Canvas2DLayerBridge(IntSize(300, 300), 0, kNonOpaque,
+                              Canvas2DLayerBridge::kEnableAcceleration,
+                              CanvasColorParams(), IsUnitTest())));
   bridge->DontUseIdleSchedulingForTesting();
   DrawSomething(bridge);
 
@@ -602,7 +614,7 @@ TEST_F(Canvas2DLayerBridgeTest, DISABLED_BackgroundRenderingWhileHibernating)
   ::testing::Mock::VerifyAndClearExpectations(mock_logger_ptr);
   EXPECT_FALSE(bridge->IsAccelerated());
   EXPECT_TRUE(bridge->IsHibernating());
-  EXPECT_TRUE(bridge->CheckSurfaceValid());
+  EXPECT_TRUE(bridge->IsValid());
 
   // Rendering in the background -> temp switch to SW
   EXPECT_CALL(*mock_logger_ptr,
@@ -613,7 +625,7 @@ TEST_F(Canvas2DLayerBridgeTest, DISABLED_BackgroundRenderingWhileHibernating)
   ::testing::Mock::VerifyAndClearExpectations(mock_logger_ptr);
   EXPECT_FALSE(bridge->IsAccelerated());
   EXPECT_FALSE(bridge->IsHibernating());
-  EXPECT_TRUE(bridge->CheckSurfaceValid());
+  EXPECT_TRUE(bridge->IsValid());
 
   // Unhide
   bridge->SetIsHidden(false);
@@ -621,7 +633,7 @@ TEST_F(Canvas2DLayerBridgeTest, DISABLED_BackgroundRenderingWhileHibernating)
   EXPECT_TRUE(
       bridge->IsAccelerated());  // Becoming visible causes switch back to GPU
   EXPECT_FALSE(bridge->IsHibernating());
-  EXPECT_TRUE(bridge->CheckSurfaceValid());
+  EXPECT_TRUE(bridge->IsValid());
 }
 
 #if CANVAS2D_HIBERNATION_ENABLED && CANVAS2D_BACKGROUND_RENDER_SWITCH_TO_CPU
@@ -634,9 +646,10 @@ TEST_F(
 #endif
 {
   ScopedTestingPlatformSupport<FakePlatformSupport> platform;
-  Canvas2DLayerBridgePtr bridge(AdoptRef(new Canvas2DLayerBridge(
-      IntSize(300, 300), 0, kNonOpaque,
-      Canvas2DLayerBridge::kEnableAcceleration, CanvasColorParams())));
+  Canvas2DLayerBridgePtr bridge(WTF::WrapUnique(
+      new Canvas2DLayerBridge(IntSize(300, 300), 0, kNonOpaque,
+                              Canvas2DLayerBridge::kEnableAcceleration,
+                              CanvasColorParams(), IsUnitTest())));
   bridge->DontUseIdleSchedulingForTesting();
   DrawSomething(bridge);
   MockImageBuffer mock_image_buffer;
@@ -660,7 +673,7 @@ TEST_F(
   ::testing::Mock::VerifyAndClearExpectations(&mock_image_buffer);
   EXPECT_FALSE(bridge->IsAccelerated());
   EXPECT_TRUE(bridge->IsHibernating());
-  EXPECT_TRUE(bridge->CheckSurfaceValid());
+  EXPECT_TRUE(bridge->IsValid());
 
   // Rendering in the background -> temp switch to SW
   EXPECT_CALL(*mock_logger_ptr,
@@ -673,7 +686,7 @@ TEST_F(
   ::testing::Mock::VerifyAndClearExpectations(&mock_image_buffer);
   EXPECT_FALSE(bridge->IsAccelerated());
   EXPECT_FALSE(bridge->IsHibernating());
-  EXPECT_TRUE(bridge->CheckSurfaceValid());
+  EXPECT_TRUE(bridge->IsValid());
 
   // Unhide
   EXPECT_CALL(mock_image_buffer, ResetCanvas(_)).Times(AtLeast(1));
@@ -683,7 +696,7 @@ TEST_F(
   EXPECT_TRUE(
       bridge->IsAccelerated());  // Becoming visible causes switch back to GPU
   EXPECT_FALSE(bridge->IsHibernating());
-  EXPECT_TRUE(bridge->CheckSurfaceValid());
+  EXPECT_TRUE(bridge->IsValid());
 }
 
 #if CANVAS2D_HIBERNATION_ENABLED && CANVAS2D_BACKGROUND_RENDER_SWITCH_TO_CPU
@@ -694,9 +707,10 @@ TEST_F(Canvas2DLayerBridgeTest,
 #endif
 {
   ScopedTestingPlatformSupport<FakePlatformSupport> platform;
-  Canvas2DLayerBridgePtr bridge(AdoptRef(new Canvas2DLayerBridge(
-      IntSize(300, 300), 0, kNonOpaque,
-      Canvas2DLayerBridge::kEnableAcceleration, CanvasColorParams())));
+  Canvas2DLayerBridgePtr bridge(WTF::WrapUnique(
+      new Canvas2DLayerBridge(IntSize(300, 300), 0, kNonOpaque,
+                              Canvas2DLayerBridge::kEnableAcceleration,
+                              CanvasColorParams(), IsUnitTest())));
   bridge->DontUseIdleSchedulingForTesting();
   DrawSomething(bridge);
 
@@ -720,7 +734,7 @@ TEST_F(Canvas2DLayerBridgeTest,
   ::testing::Mock::VerifyAndClearExpectations(&mock_image_buffer);
   EXPECT_FALSE(bridge->IsAccelerated());
   EXPECT_TRUE(bridge->IsHibernating());
-  EXPECT_TRUE(bridge->CheckSurfaceValid());
+  EXPECT_TRUE(bridge->IsValid());
 
   // Disable deferral while background rendering
   EXPECT_CALL(*mock_logger_ptr,
@@ -733,7 +747,7 @@ TEST_F(Canvas2DLayerBridgeTest,
   ::testing::Mock::VerifyAndClearExpectations(&mock_image_buffer);
   EXPECT_FALSE(bridge->IsAccelerated());
   EXPECT_FALSE(bridge->IsHibernating());
-  EXPECT_TRUE(bridge->CheckSurfaceValid());
+  EXPECT_TRUE(bridge->IsValid());
 
   // Unhide
   EXPECT_CALL(mock_image_buffer, ResetCanvas(_)).Times(AtLeast(1));
@@ -743,7 +757,7 @@ TEST_F(Canvas2DLayerBridgeTest,
   EXPECT_TRUE(
       bridge->IsAccelerated());  // Becoming visible causes switch back to GPU
   EXPECT_FALSE(bridge->IsHibernating());
-  EXPECT_TRUE(bridge->CheckSurfaceValid());
+  EXPECT_TRUE(bridge->IsValid());
 
   EXPECT_CALL(mock_image_buffer, ResetCanvas(_)).Times(AnyNumber());
   bridge.Clear();
@@ -757,9 +771,10 @@ TEST_F(Canvas2DLayerBridgeTest, DISABLED_TeardownWhileHibernating)
 #endif
 {
   ScopedTestingPlatformSupport<FakePlatformSupport> platform;
-  Canvas2DLayerBridgePtr bridge(AdoptRef(new Canvas2DLayerBridge(
-      IntSize(300, 300), 0, kNonOpaque,
-      Canvas2DLayerBridge::kEnableAcceleration, CanvasColorParams())));
+  Canvas2DLayerBridgePtr bridge(WTF::WrapUnique(
+      new Canvas2DLayerBridge(IntSize(300, 300), 0, kNonOpaque,
+                              Canvas2DLayerBridge::kEnableAcceleration,
+                              CanvasColorParams(), IsUnitTest())));
   bridge->DontUseIdleSchedulingForTesting();
   DrawSomething(bridge);
 
@@ -778,7 +793,7 @@ TEST_F(Canvas2DLayerBridgeTest, DISABLED_TeardownWhileHibernating)
   ::testing::Mock::VerifyAndClearExpectations(mock_logger_ptr);
   EXPECT_FALSE(bridge->IsAccelerated());
   EXPECT_TRUE(bridge->IsHibernating());
-  EXPECT_TRUE(bridge->CheckSurfaceValid());
+  EXPECT_TRUE(bridge->IsValid());
 
   // Tear down the bridge while hibernating
   EXPECT_CALL(*mock_logger_ptr,
@@ -795,9 +810,10 @@ TEST_F(Canvas2DLayerBridgeTest, DISABLED_SnapshotWhileHibernating)
 #endif
 {
   ScopedTestingPlatformSupport<FakePlatformSupport> platform;
-  Canvas2DLayerBridgePtr bridge(AdoptRef(new Canvas2DLayerBridge(
-      IntSize(300, 300), 0, kNonOpaque,
-      Canvas2DLayerBridge::kEnableAcceleration, CanvasColorParams())));
+  Canvas2DLayerBridgePtr bridge(WTF::WrapUnique(
+      new Canvas2DLayerBridge(IntSize(300, 300), 0, kNonOpaque,
+                              Canvas2DLayerBridge::kEnableAcceleration,
+                              CanvasColorParams(), IsUnitTest())));
   bridge->DontUseIdleSchedulingForTesting();
   DrawSomething(bridge);
 
@@ -816,7 +832,7 @@ TEST_F(Canvas2DLayerBridgeTest, DISABLED_SnapshotWhileHibernating)
   ::testing::Mock::VerifyAndClearExpectations(mock_logger_ptr);
   EXPECT_FALSE(bridge->IsAccelerated());
   EXPECT_TRUE(bridge->IsHibernating());
-  EXPECT_TRUE(bridge->CheckSurfaceValid());
+  EXPECT_TRUE(bridge->IsValid());
 
   // Take a snapshot and verify that it is not accelerated due to hibernation
   RefPtr<StaticBitmapImage> image =
@@ -827,7 +843,7 @@ TEST_F(Canvas2DLayerBridgeTest, DISABLED_SnapshotWhileHibernating)
   // Verify that taking a snapshot did not affect the state of bridge
   EXPECT_FALSE(bridge->IsAccelerated());
   EXPECT_TRUE(bridge->IsHibernating());
-  EXPECT_TRUE(bridge->CheckSurfaceValid());
+  EXPECT_TRUE(bridge->IsValid());
 
   // End hibernation normally
   EXPECT_CALL(
@@ -844,9 +860,10 @@ TEST_F(Canvas2DLayerBridgeTest, DISABLED_TeardownWhileHibernationIsPending)
 #endif
 {
   ScopedTestingPlatformSupport<FakePlatformSupport> platform;
-  Canvas2DLayerBridgePtr bridge(AdoptRef(new Canvas2DLayerBridge(
-      IntSize(300, 300), 0, kNonOpaque,
-      Canvas2DLayerBridge::kEnableAcceleration, CanvasColorParams())));
+  Canvas2DLayerBridgePtr bridge(WTF::WrapUnique(
+      new Canvas2DLayerBridge(IntSize(300, 300), 0, kNonOpaque,
+                              Canvas2DLayerBridge::kEnableAcceleration,
+                              CanvasColorParams(), IsUnitTest())));
   bridge->DontUseIdleSchedulingForTesting();
   DrawSomething(bridge);
 
@@ -877,9 +894,10 @@ TEST_F(Canvas2DLayerBridgeTest, DISABLED_HibernationAbortedDueToPendingTeardown)
 #endif
 {
   ScopedTestingPlatformSupport<FakePlatformSupport> platform;
-  Canvas2DLayerBridgePtr bridge(AdoptRef(new Canvas2DLayerBridge(
-      IntSize(300, 300), 0, kNonOpaque,
-      Canvas2DLayerBridge::kEnableAcceleration, CanvasColorParams())));
+  Canvas2DLayerBridgePtr bridge(WTF::WrapUnique(
+      new Canvas2DLayerBridge(IntSize(300, 300), 0, kNonOpaque,
+                              Canvas2DLayerBridge::kEnableAcceleration,
+                              CanvasColorParams(), IsUnitTest())));
   bridge->DontUseIdleSchedulingForTesting();
   DrawSomething(bridge);
 
@@ -912,9 +930,10 @@ TEST_F(Canvas2DLayerBridgeTest,
 #endif
 {
   ScopedTestingPlatformSupport<FakePlatformSupport> platform;
-  Canvas2DLayerBridgePtr bridge(AdoptRef(new Canvas2DLayerBridge(
-      IntSize(300, 300), 0, kNonOpaque,
-      Canvas2DLayerBridge::kEnableAcceleration, CanvasColorParams())));
+  Canvas2DLayerBridgePtr bridge(WTF::WrapUnique(
+      new Canvas2DLayerBridge(IntSize(300, 300), 0, kNonOpaque,
+                              Canvas2DLayerBridge::kEnableAcceleration,
+                              CanvasColorParams(), IsUnitTest())));
   bridge->DontUseIdleSchedulingForTesting();
   DrawSomething(bridge);
 
@@ -938,7 +957,7 @@ TEST_F(Canvas2DLayerBridgeTest,
   ::testing::Mock::VerifyAndClearExpectations(mock_logger_ptr);
   EXPECT_TRUE(bridge->IsAccelerated());
   EXPECT_FALSE(bridge->IsHibernating());
-  EXPECT_TRUE(bridge->CheckSurfaceValid());
+  EXPECT_TRUE(bridge->IsValid());
 }
 
 #if CANVAS2D_HIBERNATION_ENABLED
@@ -948,9 +967,10 @@ TEST_F(Canvas2DLayerBridgeTest, DISABLED_HibernationAbortedDueToLostContext)
 #endif
 {
   ScopedTestingPlatformSupport<FakePlatformSupport> platform;
-  Canvas2DLayerBridgePtr bridge(AdoptRef(new Canvas2DLayerBridge(
-      IntSize(300, 300), 0, kNonOpaque,
-      Canvas2DLayerBridge::kEnableAcceleration, CanvasColorParams())));
+  Canvas2DLayerBridgePtr bridge(WTF::WrapUnique(
+      new Canvas2DLayerBridge(IntSize(300, 300), 0, kNonOpaque,
+                              Canvas2DLayerBridge::kEnableAcceleration,
+                              CanvasColorParams(), IsUnitTest())));
   bridge->DontUseIdleSchedulingForTesting();
   DrawSomething(bridge);
 
@@ -983,9 +1003,10 @@ TEST_F(Canvas2DLayerBridgeTest, DISABLED_PrepareMailboxWhileHibernating)
 #endif
 {
   ScopedTestingPlatformSupport<FakePlatformSupport> platform;
-  Canvas2DLayerBridgePtr bridge(AdoptRef(new Canvas2DLayerBridge(
-      IntSize(300, 300), 0, kNonOpaque,
-      Canvas2DLayerBridge::kEnableAcceleration, CanvasColorParams())));
+  Canvas2DLayerBridgePtr bridge(WTF::WrapUnique(
+      new Canvas2DLayerBridge(IntSize(300, 300), 0, kNonOpaque,
+                              Canvas2DLayerBridge::kEnableAcceleration,
+                              CanvasColorParams(), IsUnitTest())));
   bridge->DontUseIdleSchedulingForTesting();
   DrawSomething(bridge);
 
@@ -1008,7 +1029,7 @@ TEST_F(Canvas2DLayerBridgeTest, DISABLED_PrepareMailboxWhileHibernating)
   std::unique_ptr<viz::SingleReleaseCallback> release_callback;
   EXPECT_FALSE(
       bridge->PrepareTextureMailbox(&texture_mailbox, &release_callback));
-  EXPECT_TRUE(bridge->CheckSurfaceValid());
+  EXPECT_TRUE(bridge->IsValid());
 
   // Tear down the bridge on the thread so that 'bridge' can go out of scope
   // without crashing due to thread checks
@@ -1026,9 +1047,10 @@ TEST_F(Canvas2DLayerBridgeTest, DISABLED_PrepareMailboxWhileBackgroundRendering)
 #endif
 {
   ScopedTestingPlatformSupport<FakePlatformSupport> platform;
-  Canvas2DLayerBridgePtr bridge(AdoptRef(new Canvas2DLayerBridge(
-      IntSize(300, 300), 0, kNonOpaque,
-      Canvas2DLayerBridge::kEnableAcceleration, CanvasColorParams())));
+  Canvas2DLayerBridgePtr bridge(WTF::WrapUnique(
+      new Canvas2DLayerBridge(IntSize(300, 300), 0, kNonOpaque,
+                              Canvas2DLayerBridge::kEnableAcceleration,
+                              CanvasColorParams(), IsUnitTest())));
   DrawSomething(bridge);
 
   // Register an alternate Logger for tracking hibernation events
@@ -1056,14 +1078,14 @@ TEST_F(Canvas2DLayerBridgeTest, DISABLED_PrepareMailboxWhileBackgroundRendering)
   ::testing::Mock::VerifyAndClearExpectations(mock_logger_ptr);
   EXPECT_FALSE(bridge->IsAccelerated());
   EXPECT_FALSE(bridge->IsHibernating());
-  EXPECT_TRUE(bridge->CheckSurfaceValid());
+  EXPECT_TRUE(bridge->IsValid());
 
   // Test prepareMailbox while background rendering
   viz::TextureMailbox texture_mailbox;
   std::unique_ptr<viz::SingleReleaseCallback> release_callback;
   EXPECT_FALSE(
       bridge->PrepareTextureMailbox(&texture_mailbox, &release_callback));
-  EXPECT_TRUE(bridge->CheckSurfaceValid());
+  EXPECT_TRUE(bridge->IsValid());
 }
 
 #if USE_IOSURFACE_FOR_2D_CANVAS
@@ -1078,10 +1100,10 @@ TEST_F(Canvas2DLayerBridgeTest, DISABLED_DeleteIOSurfaceAfterTeardown)
   std::unique_ptr<viz::SingleReleaseCallback> release_callback;
 
   {
-    Canvas2DLayerBridgePtr bridge(AdoptRef(new Canvas2DLayerBridge(
+    Canvas2DLayerBridgePtr bridge(WTF::WrapUnique(new Canvas2DLayerBridge(
         IntSize(300, 150), 0, kNonOpaque,
-        Canvas2DLayerBridge::kForceAccelerationForTesting,
-        CanvasColorParams())));
+        Canvas2DLayerBridge::kForceAccelerationForTesting, CanvasColorParams(),
+        IsUnitTest())));
     bridge->PrepareTextureMailbox(&texture_mailbox, &release_callback);
   }
 
@@ -1099,9 +1121,10 @@ class FlushMockGLES2Interface : public gpu::gles2::GLES2InterfaceStub {
 
 TEST_F(Canvas2DLayerBridgeTest, NoUnnecessaryFlushes) {
   EXPECT_CALL(gl_, Flush()).Times(0);
-  Canvas2DLayerBridgePtr bridge(AdoptRef(new Canvas2DLayerBridge(
-      IntSize(300, 150), 0, kNonOpaque,
-      Canvas2DLayerBridge::kForceAccelerationForTesting, CanvasColorParams())));
+  Canvas2DLayerBridgePtr bridge(WTF::WrapUnique(
+      new Canvas2DLayerBridge(IntSize(300, 150), 0, kNonOpaque,
+                              Canvas2DLayerBridge::kForceAccelerationForTesting,
+                              CanvasColorParams(), IsUnitTest())));
   EXPECT_FALSE(bridge->HasRecordedDrawCommands());
   ::testing::Mock::VerifyAndClearExpectations(&gl_);
 
@@ -1111,7 +1134,7 @@ TEST_F(Canvas2DLayerBridgeTest, NoUnnecessaryFlushes) {
   ::testing::Mock::VerifyAndClearExpectations(&gl_);
 
   EXPECT_CALL(gl_, Flush()).Times(1);
-  bridge->FlushGpu();
+  bridge->FlushGpu(kFlushReasonUnknown);
   EXPECT_FALSE(bridge->HasRecordedDrawCommands());
   ::testing::Mock::VerifyAndClearExpectations(&gl_);
 
@@ -1121,13 +1144,13 @@ TEST_F(Canvas2DLayerBridgeTest, NoUnnecessaryFlushes) {
   ::testing::Mock::VerifyAndClearExpectations(&gl_);
 
   EXPECT_CALL(gl_, Flush()).Times(1);
-  bridge->FlushGpu();
+  bridge->FlushGpu(kFlushReasonUnknown);
   EXPECT_FALSE(bridge->HasRecordedDrawCommands());
   ::testing::Mock::VerifyAndClearExpectations(&gl_);
 
   // No flush because already flushed since last draw
   EXPECT_CALL(gl_, Flush()).Times(0);
-  bridge->FlushGpu();
+  bridge->FlushGpu(kFlushReasonUnknown);
   EXPECT_FALSE(bridge->HasRecordedDrawCommands());
   ::testing::Mock::VerifyAndClearExpectations(&gl_);
 
@@ -1138,12 +1161,12 @@ TEST_F(Canvas2DLayerBridgeTest, NoUnnecessaryFlushes) {
 
   // Flushes recording, but not the gpu
   EXPECT_CALL(gl_, Flush()).Times(0);
-  bridge->Flush();
+  bridge->Flush(kFlushReasonUnknown);
   EXPECT_FALSE(bridge->HasRecordedDrawCommands());
   ::testing::Mock::VerifyAndClearExpectations(&gl_);
 
   EXPECT_CALL(gl_, Flush()).Times(1);
-  bridge->FlushGpu();
+  bridge->FlushGpu(kFlushReasonUnknown);
   EXPECT_FALSE(bridge->HasRecordedDrawCommands());
   ::testing::Mock::VerifyAndClearExpectations(&gl_);
 }

third_party/WebKit/Source/platform/graphics/gpu/SharedGpuContextTest.cpp

@@ -32,6 +32,8 @@ class SharedGpuContextTest : public Test {
     SharedGpuContext::SetContextProviderFactoryForTesting(nullptr);
   }
 
+  bool IsUnitTest() { return true; }
+
   FakeGLES2Interface gl_;
 };
 
@@ -80,9 +82,11 @@ TEST_F(SharedGpuContextTest, Canvas2DLayerBridgeAutoRecovery) {
   EXPECT_FALSE(SharedGpuContext::IsValidWithoutRestoring());
   IntSize size(10, 10);
   CanvasColorParams color_params;
-  RefPtr<Canvas2DLayerBridge> bridge = AdoptRef(new Canvas2DLayerBridge(
+  std::unique_ptr<Canvas2DLayerBridge> bridge =
+      WTF::WrapUnique(new Canvas2DLayerBridge(
           size, 0, /*msaa sample count*/
-      kNonOpaque, Canvas2DLayerBridge::kEnableAcceleration, color_params));
+          kNonOpaque, Canvas2DLayerBridge::kEnableAcceleration, color_params,
+          IsUnitTest()));
   EXPECT_TRUE(bridge->IsAccelerated());
   EXPECT_TRUE(SharedGpuContext::IsValidWithoutRestoring());
   bridge->BeginDestruction();