cc: Make LayerTreeTests use a DelegatingRenderer and Display.

cc/trees/layer_tree_host_unittest_context.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/memory/ptr_util.h"
 #include "cc/layers/heads_up_display_layer.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/layers/painted_scrollbar_layer.h"
 #include "cc/layers/picture_layer.h"
 #include "cc/layers/texture_layer.h"
 #include "cc/layers/texture_layer_impl.h"
 #include "cc/layers/video_layer.h"
 #include "cc/layers/video_layer_impl.h"
 #include "cc/output/filter_operations.h"
 #include "cc/resources/single_release_callback.h"
-#include "cc/test/failure_output_surface.h"
 #include "cc/test/fake_content_layer_client.h"
 #include "cc/test/fake_layer_tree_host_client.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/fake_output_surface_client.h"
 #include "cc/test/fake_painted_scrollbar_layer.h"
 #include "cc/test/fake_picture_layer.h"
 #include "cc/test/fake_picture_layer_impl.h"
 #include "cc/test/fake_resource_provider.h"
 #include "cc/test/fake_scoped_ui_resource.h"
 #include "cc/test/fake_scrollbar.h"
 #include "cc/test/fake_video_frame_provider.h"
 #include "cc/test/layer_tree_test.h"
 #include "cc/test/render_pass_test_utils.h"
 #include "cc/test/test_context_provider.h"
+#include "cc/test/test_delegating_output_surface.h"
 #include "cc/test/test_shared_bitmap_manager.h"
 #include "cc/test/test_web_graphics_context_3d.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_host_impl.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "media/base/media.h"
 
 using media::VideoFrame;
@@ skipping 29 matching lines @@
     CHECK(context3d_);
     context3d_->loseContextCHROMIUM(GL_GUILTY_CONTEXT_RESET_ARB,
                                     GL_INNOCENT_CONTEXT_RESET_ARB);
     context3d_ = NULL;
   }
 
   virtual std::unique_ptr<TestWebGraphicsContext3D> CreateContext3d() {
     return TestWebGraphicsContext3D::Create();
   }
 
-  std::unique_ptr<OutputSurface> CreateOutputSurface() override {
+  std::unique_ptr<TestDelegatingOutputSurface> CreateDelegatingOutputSurface(
+      scoped_refptr<ContextProvider> compositor_context_provider,
+      scoped_refptr<ContextProvider> worker_context_provider) override {
     if (times_to_fail_create_) {
       --times_to_fail_create_;
       ExpectCreateToFail();
-      return base::WrapUnique(new FailureOutputSurface(delegating_renderer()));
+      auto test_compositor_context_provider = TestContextProvider::Create();
+      test_compositor_context_provider->UnboundTestContext3d()
+          ->loseContextCHROMIUM(GL_GUILTY_CONTEXT_RESET_ARB,
+                                GL_INNOCENT_CONTEXT_RESET_ARB);
+      compositor_context_provider = std::move(test_compositor_context_provider);
+    }
+    return LayerTreeTest::CreateDelegatingOutputSurface(
+        std::move(compositor_context_provider),
+        std::move(worker_context_provider));
+  }
+
+  std::unique_ptr<OutputSurface> CreateDisplayOutputSurface(
+      scoped_refptr<ContextProvider> compositor_context_provider) override {
+    std::unique_ptr<TestWebGraphicsContext3D> context3d = CreateContext3d();
+    if (context_should_support_io_surface_) {
+      context3d->set_have_extension_io_surface(true);
+      context3d->set_have_extension_egl_image(true);
     }
 
-    std::unique_ptr<TestWebGraphicsContext3D> context3d = CreateContext3d();
     base::AutoLock lock(context3d_lock_);
     context3d_ = context3d.get();
-
-    if (context_should_support_io_surface_) {
-      context3d_->set_have_extension_io_surface(true);
-      context3d_->set_have_extension_egl_image(true);
-    }
-
-    DCHECK(delegating_renderer());
-    return FakeOutputSurface::CreateDelegating3d(std::move(context3d));
+    return LayerTreeTest::CreateDisplayOutputSurface(
+        TestContextProvider::Create(std::move(context3d)));
   }
 
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                    LayerTreeHostImpl::FrameData* frame,
                                    DrawResult draw_result) override {
     if (draw_result == DRAW_ABORTED_MISSING_HIGH_RES_CONTENT) {
       // Only valid for single-threaded compositing, which activates
       // immediately and will try to draw again when content has finished.
       DCHECK(!host_impl->task_runner_provider()->HasImplThread());
       return draw_result;
@@ skipping 60 matching lines @@
         num_losses_last_test_case_(-1),
         recovered_context_(true),
         first_initialized_(false) {}
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void RequestNewOutputSurface() override {
     if (async_output_surface_creation_) {
       MainThreadTaskRunner()->PostTask(
           FROM_HERE, base::Bind(&LayerTreeHostContextTestLostContextSucceeds::
-                                    CreateAndSetOutputSurface,
+                                    AsyncRequestNewOutputSurface,
                                 base::Unretained(this)));
     } else {
-      CreateAndSetOutputSurface();
+      AsyncRequestNewOutputSurface();
     }
   }
 
-  void CreateAndSetOutputSurface() {
-    std::unique_ptr<OutputSurface> surface(
-        LayerTreeHostContextTest::CreateOutputSurface());
-    CHECK(surface);
-    layer_tree_host()->SetOutputSurface(std::move(surface));
+  void AsyncRequestNewOutputSurface() {
+    LayerTreeHostContextTest::RequestNewOutputSurface();
   }
 
   void DidInitializeOutputSurface() override {
     if (first_initialized_)
       ++num_losses_;
     else
       first_initialized_ = true;
 
     recovered_context_ = true;
   }
@@ skipping 155 matching lines @@
   void WillBeginTest() override {
     // Override to not become visible.
     DCHECK(!layer_tree_host()->visible());
   }
 
   void BeginTest() override {
     PostSetNeedsCommitToMainThread();
     EndTest();
   }
 
-  std::unique_ptr<OutputSurface> CreateOutputSurface() override {
-    EXPECT_TRUE(false);
-    return nullptr;
+  void RequestNewOutputSurface() override {
+    ADD_FAILURE() << "RequestNewOutputSurface() should not be called";
   }
 
   void DidInitializeOutputSurface() override { EXPECT_TRUE(false); }
 
   void AfterTest() override {}
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostClientNotVisibleDoesNotCreateOutputSurface);
 
 // This tests the OutputSurface release logic in the following sequence.
 // SetUp LTH and create and init OutputSurface
 // LTH::SetVisible(false);
 // LTH::ReleaseOutputSurface();
 // ...
 // LTH::SetVisible(true);
 // Create and init new OutputSurface
 class LayerTreeHostClientTakeAwayOutputSurface
     : public LayerTreeHostContextTest {
  public:
   LayerTreeHostClientTakeAwayOutputSurface()
       : LayerTreeHostContextTest(), setos_counter_(0) {}
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void RequestNewOutputSurface() override {
-    if (layer_tree_host()->visible())
-      CreateAndSetOutputSurface();
-  }
-
-  void CreateAndSetOutputSurface() {
-    std::unique_ptr<OutputSurface> surface =
-        LayerTreeHostContextTest::CreateOutputSurface();
-    CHECK(surface);
-    setos_counter_++;
-    layer_tree_host()->SetOutputSurface(std::move(surface));
+    if (layer_tree_host()->visible()) {
+      setos_counter_++;
+      LayerTreeHostContextTest::RequestNewOutputSurface();
+    }
   }
 
   void HideAndReleaseOutputSurface() {
     EXPECT_TRUE(layer_tree_host()->task_runner_provider()->IsMainThread());
     layer_tree_host()->SetVisible(false);
     std::unique_ptr<OutputSurface> surface =
         layer_tree_host()->ReleaseOutputSurface();
     CHECK(surface);
     MainThreadTaskRunner()->PostTask(
         FROM_HERE,
@@ skipping 39 matching lines @@
   void RequestNewOutputSurface() override {
     EXPECT_GE(1, ++request_count_);
     EndTest();
   }
 
   void BeginTest() override {
     layer_tree_host()->Composite(base::TimeTicks::FromInternalValue(1));
     layer_tree_host()->Composite(base::TimeTicks::FromInternalValue(2));
   }
 
-  std::unique_ptr<OutputSurface> CreateOutputSurface() override {
-    EXPECT_TRUE(false);
-    return nullptr;
-  }
-
   void DidInitializeOutputSurface() override { EXPECT_TRUE(false); }
 
   void AfterTest() override {}
 
   int request_count_;
 };
 
 // This test uses Composite() which only exists for single thread.
 SINGLE_THREAD_TEST_F(MultipleCompositeDoesNotCreateOutputSurface);
 
@@ skipping 12 matching lines @@
   }
 
   void RequestNewOutputSurface() override {
     num_requests_++;
     // There should be one initial request and then one request from
     // the LayerTreeTest test hooks DidFailToInitializeOutputSurface (which is
     // hard to skip).  This second request is just ignored and is test cruft.
     EXPECT_LE(num_requests_, 2);
     if (num_requests_ > 1)
       return;
+    LayerTreeHostContextTest::RequestNewOutputSurface();
+  }
+
+  std::unique_ptr<TestDelegatingOutputSurface> CreateDelegatingOutputSurface(
+      scoped_refptr<ContextProvider> compositor_context_provider,
+      scoped_refptr<ContextProvider> worker_context_provider) override {
     ExpectCreateToFail();
-    layer_tree_host()->SetOutputSurface(
-        base::WrapUnique(new FailureOutputSurface(false)));
+    auto test_compositor_context_provider = TestContextProvider::Create();
+    test_compositor_context_provider->UnboundTestContext3d()
+        ->loseContextCHROMIUM(GL_GUILTY_CONTEXT_RESET_ARB,
+                              GL_INNOCENT_CONTEXT_RESET_ARB);
+    return LayerTreeTest::CreateDelegatingOutputSurface(
+        std::move(test_compositor_context_provider),
+        std::move(worker_context_provider));
   }
 
   void BeginTest() override {
     // First composite tries to create a surface.
     layer_tree_host()->Composite(base::TimeTicks::FromInternalValue(1));
     EXPECT_EQ(num_requests_, 2);
     EXPECT_TRUE(has_failed_);
 
     // Second composite should not request or fail.
     layer_tree_host()->Composite(base::TimeTicks::FromInternalValue(2));
@@ skipping 32 matching lines @@
   void RequestNewOutputSurface() override {
     MainThreadTaskRunner()->PostTask(
         FROM_HERE,
         base::Bind(&LayerTreeHostContextTestCommitAfterDelayedOutputSurface::
                        CreateAndSetOutputSurface,
                    base::Unretained(this)));
   }
 
   void CreateAndSetOutputSurface() {
     creating_output_ = true;
-    layer_tree_host()->SetOutputSurface(
-        LayerTreeHostContextTest::CreateOutputSurface());
+    LayerTreeHostContextTest::RequestNewOutputSurface();
   }
 
   void BeginTest() override {
     layer_tree_host()->Composite(base::TimeTicks::FromInternalValue(1));
   }
 
   void ScheduleComposite() override {
     if (creating_output_)
       EndTest();
   }
@@ skipping 11 matching lines @@
  public:
   LayerTreeHostContextTestAvoidUnnecessaryComposite()
       : LayerTreeHostContextTest(), in_composite_(false) {}
 
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->single_thread_proxy_scheduler = false;
     settings->use_zero_copy = true;
   }
 
   void RequestNewOutputSurface() override {
-    layer_tree_host()->SetOutputSurface(
-        LayerTreeHostContextTest::CreateOutputSurface());
+    LayerTreeHostContextTest::RequestNewOutputSurface();
     EndTest();
   }
 
   void BeginTest() override {
     in_composite_ = true;
     layer_tree_host()->Composite(base::TimeTicks::FromInternalValue(1));
     in_composite_ = false;
   }
 
   void ScheduleComposite() override { EXPECT_FALSE(in_composite_); }
@@ skipping 426 matching lines @@
                                    LayerTreeHostImpl::FrameData* frame,
                                    DrawResult draw_result) override {
     if (host_impl->active_tree()->source_frame_number() == 2) {
       // Lose the context during draw on the second commit. This will cause
       // a third commit to recover.
       context3d_->set_times_bind_texture_succeeds(0);
     }
     return draw_result;
   }
 
-  std::unique_ptr<OutputSurface> CreateOutputSurface() override {
+  void RequestNewOutputSurface() override {
     // This will get called twice:
     // First when we create the initial output surface...
     if (layer_tree_host()->source_frame_number() > 0) {
       // ... and then again after we forced the context to be lost.
       lost_context_ = true;
     }
-    return LayerTreeHostContextTest::CreateOutputSurface();
+    LayerTreeHostContextTest::RequestNewOutputSurface();
   }
 
   void DidCommitAndDrawFrame() override {
     ASSERT_TRUE(layer_tree_host()->hud_layer());
     // End the test once we know the 3nd frame drew.
     if (layer_tree_host()->source_frame_number() < 5) {
       layer_tree_host()->root_layer()->SetNeedsDisplay();
       layer_tree_host()->SetNeedsCommit();
     } else {
       EndTest();
@@ skipping 516 matching lines @@
   void AfterTest() override {}
 
   bool deferred_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostContextTestLoseAfterSendingBeginMainFrame);
 
 }  // namespace
 }  // namespace cc