Fork cc::OutputSurface into cc::CompositorFrameSink.

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/resources/ui_resource_manager.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_compositor_frame_sink.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;
 
 namespace cc {
 namespace {
 
 // These tests deal with losing the 3d graphics context.
 class LayerTreeHostContextTest : public LayerTreeTest {
  public:
   LayerTreeHostContextTest()
       : LayerTreeTest(),
         context3d_(NULL),
         times_to_fail_create_(0),
         times_to_lose_during_commit_(0),
         times_to_lose_during_draw_(0),
         times_to_fail_recreate_(0),
         times_to_expect_create_failed_(0),
         times_create_failed_(0),
         committed_at_least_once_(false),
         context_should_support_io_surface_(false),
         fallback_context_works_(false),
-        async_output_surface_creation_(false) {
+        async_compositor_frame_sink_creation_(false) {
     media::InitializeMediaLibrary();
   }
 
   void LoseContext() {
-    // CreateFakeOutputSurface happens on a different thread, so lock context3d_
-    // to make sure we don't set it to null after recreating it there.
+    // CreateDisplayCompositorFrameSink happens on a different thread, so lock
+    // context3d_ to make sure we don't set it to null after recreating it
+    // there.
     base::AutoLock lock(context3d_lock_);
     // For sanity-checking tests, they should only call this when the
     // context is not lost.
     CHECK(context3d_);
     context3d_->loseContextCHROMIUM(GL_GUILTY_CONTEXT_RESET_ARB,
                                     GL_INNOCENT_CONTEXT_RESET_ARB);
-    context3d_ = NULL;
+    context3d_ = nullptr;
   }
 
   virtual std::unique_ptr<TestWebGraphicsContext3D> CreateContext3d() {
     return TestWebGraphicsContext3D::Create();
   }
 
-  std::unique_ptr<TestDelegatingOutputSurface> CreateDelegatingOutputSurface(
+  std::unique_ptr<TestCompositorFrameSink> CreateCompositorFrameSink(
       scoped_refptr<ContextProvider> compositor_context_provider,
       scoped_refptr<ContextProvider> worker_context_provider) override {
     if (times_to_fail_create_) {
       --times_to_fail_create_;
       ExpectCreateToFail();
       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(
+    return LayerTreeTest::CreateCompositorFrameSink(
         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);
@@ skipping 32 matching lines @@
 
     if (!times_to_lose_during_commit_)
       return;
     --times_to_lose_during_commit_;
     LoseContext();
 
     times_to_fail_create_ = times_to_fail_recreate_;
     times_to_fail_recreate_ = 0;
   }
 
-  void DidFailToInitializeOutputSurface() override { ++times_create_failed_; }
+  void DidFailToInitializeCompositorFrameSink() override {
+    ++times_create_failed_;
+  }
 
   void TearDown() override {
     LayerTreeTest::TearDown();
     EXPECT_EQ(times_to_expect_create_failed_, times_create_failed_);
   }
 
   void ExpectCreateToFail() { ++times_to_expect_create_failed_; }
 
  protected:
-  // Protects use of context3d_ so LoseContext and CreateFakeOutputSurface
-  // can both use it on different threads.
+  // Protects use of context3d_ so LoseContext and
+  // CreateDisplayCompositorFrameSink can both use it on different threads.
   base::Lock context3d_lock_;
   TestWebGraphicsContext3D* context3d_;
 
   int times_to_fail_create_;
   int times_to_lose_during_commit_;
   int times_to_lose_during_draw_;
   int times_to_fail_recreate_;
   int times_to_expect_create_failed_;
   int times_create_failed_;
   bool committed_at_least_once_;
   bool context_should_support_io_surface_;
   bool fallback_context_works_;
-  bool async_output_surface_creation_;
+  bool async_compositor_frame_sink_creation_;
 };
 
 class LayerTreeHostContextTestLostContextSucceeds
     : public LayerTreeHostContextTest {
  public:
   LayerTreeHostContextTestLostContextSucceeds()
       : LayerTreeHostContextTest(),
         test_case_(0),
         num_losses_(0),
         num_losses_last_test_case_(-1),
         recovered_context_(true),
         first_initialized_(false) {}
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  void RequestNewOutputSurface() override {
-    if (async_output_surface_creation_) {
+  void RequestNewCompositorFrameSink() override {
+    if (async_compositor_frame_sink_creation_) {
       MainThreadTaskRunner()->PostTask(
           FROM_HERE, base::Bind(&LayerTreeHostContextTestLostContextSucceeds::
-                                    AsyncRequestNewOutputSurface,
+                                    AsyncRequestNewCompositorFrameSink,
                                 base::Unretained(this)));
     } else {
-      AsyncRequestNewOutputSurface();
+      AsyncRequestNewCompositorFrameSink();
     }
   }
 
-  void AsyncRequestNewOutputSurface() {
-    LayerTreeHostContextTest::RequestNewOutputSurface();
+  void AsyncRequestNewCompositorFrameSink() {
+    LayerTreeHostContextTest::RequestNewCompositorFrameSink();
   }
 
-  void DidInitializeOutputSurface() override {
+  void DidInitializeCompositorFrameSink() override {
     if (first_initialized_)
       ++num_losses_;
     else
       first_initialized_ = true;
 
     recovered_context_ = true;
   }
 
   void AfterTest() override { EXPECT_EQ(11u, test_case_); }
 
@@ skipping 18 matching lines @@
     // Cause damage so we try to draw.
     layer_tree()->root_layer()->SetNeedsDisplay();
     layer_tree_host()->SetNeedsCommit();
   }
 
   bool NextTestCase() {
     static const TestCase kTests[] = {
         // Losing the context and failing to recreate it (or losing it again
         // immediately) a small number of times should succeed.
         {
-         1,      // times_to_lose_during_commit
-         0,      // times_to_lose_during_draw
-         0,      // times_to_fail_recreate
-         false,  // fallback_context_works
-         false,  // async_output_surface_creation
+            1,      // times_to_lose_during_commit
+            0,      // times_to_lose_during_draw
+            0,      // times_to_fail_recreate
+            false,  // fallback_context_works
+            false,  // async_compositor_frame_sink_creation
         },
         {
-         0,      // times_to_lose_during_commit
-         1,      // times_to_lose_during_draw
-         0,      // times_to_fail_recreate
-         false,  // fallback_context_works
-         false,  // async_output_surface_creation
+            0,      // times_to_lose_during_commit
+            1,      // times_to_lose_during_draw
+            0,      // times_to_fail_recreate
+            false,  // fallback_context_works
+            false,  // async_compositor_frame_sink_creation
         },
         {
-         1,      // times_to_lose_during_commit
-         0,      // times_to_lose_during_draw
-         3,      // times_to_fail_recreate
-         false,  // fallback_context_works
-         false,  // async_output_surface_creation
+            1,      // times_to_lose_during_commit
+            0,      // times_to_lose_during_draw
+            3,      // times_to_fail_recreate
+            false,  // fallback_context_works
+            false,  // async_compositor_frame_sink_creation
         },
         {
-         0,      // times_to_lose_during_commit
-         1,      // times_to_lose_during_draw
-         3,      // times_to_fail_recreate
-         false,  // fallback_context_works
-         false,  // async_output_surface_creation
+            0,      // times_to_lose_during_commit
+            1,      // times_to_lose_during_draw
+            3,      // times_to_fail_recreate
+            false,  // fallback_context_works
+            false,  // async_compositor_frame_sink_creation
         },
         {
-         0,      // times_to_lose_during_commit
-         1,      // times_to_lose_during_draw
-         3,      // times_to_fail_recreate
-         false,  // fallback_context_works
-         true,   // async_output_surface_creation
+            0,      // times_to_lose_during_commit
+            1,      // times_to_lose_during_draw
+            3,      // times_to_fail_recreate
+            false,  // fallback_context_works
+            true,   // async_compositor_frame_sink_creation
         },
         // Losing the context and recreating it any number of times should
         // succeed.
         {
-         10,     // times_to_lose_during_commit
-         0,      // times_to_lose_during_draw
-         0,      // times_to_fail_recreate
-         false,  // fallback_context_works
-         false,  // async_output_surface_creation
+            10,     // times_to_lose_during_commit
+            0,      // times_to_lose_during_draw
+            0,      // times_to_fail_recreate
+            false,  // fallback_context_works
+            false,  // async_compositor_frame_sink_creation
         },
         {
-         0,      // times_to_lose_during_commit
-         10,     // times_to_lose_during_draw
-         0,      // times_to_fail_recreate
-         false,  // fallback_context_works
-         false,  // async_output_surface_creation
+            0,      // times_to_lose_during_commit
+            10,     // times_to_lose_during_draw
+            0,      // times_to_fail_recreate
+            false,  // fallback_context_works
+            false,  // async_compositor_frame_sink_creation
         },
         {
-         10,     // times_to_lose_during_commit
-         0,      // times_to_lose_during_draw
-         0,      // times_to_fail_recreate
-         false,  // fallback_context_works
-         true,   // async_output_surface_creation
+            10,     // times_to_lose_during_commit
+            0,      // times_to_lose_during_draw
+            0,      // times_to_fail_recreate
+            false,  // fallback_context_works
+            true,   // async_compositor_frame_sink_creation
         },
         {
-         0,      // times_to_lose_during_commit
-         10,     // times_to_lose_during_draw
-         0,      // times_to_fail_recreate
-         false,  // fallback_context_works
-         true,   // async_output_surface_creation
+            0,      // times_to_lose_during_commit
+            10,     // times_to_lose_during_draw
+            0,      // times_to_fail_recreate
+            false,  // fallback_context_works
+            true,   // async_compositor_frame_sink_creation
         },
         // Losing the context, failing to reinitialize it, and making a fallback
         // context should work.
         {
-         0,      // times_to_lose_during_commit
-         1,      // times_to_lose_during_draw
-         0,      // times_to_fail_recreate
-         true,   // fallback_context_works
-         false,  // async_output_surface_creation
+            0,      // times_to_lose_during_commit
+            1,      // times_to_lose_during_draw
+            0,      // times_to_fail_recreate
+            true,   // fallback_context_works
+            false,  // async_compositor_frame_sink_creation
         },
         {
-         0,     // times_to_lose_during_commit
-         1,     // times_to_lose_during_draw
-         0,     // times_to_fail_recreate
-         true,  // fallback_context_works
-         true,  // async_output_surface_creation
+            0,     // times_to_lose_during_commit
+            1,     // times_to_lose_during_draw
+            0,     // times_to_fail_recreate
+            true,  // fallback_context_works
+            true,  // async_compositor_frame_sink_creation
         },
     };
 
     if (test_case_ >= arraysize(kTests))
       return false;
     // Make sure that we lost our context at least once in the last test run so
     // the test did something.
     EXPECT_GT(num_losses_, num_losses_last_test_case_);
     num_losses_last_test_case_ = num_losses_;
 
     times_to_lose_during_commit_ =
         kTests[test_case_].times_to_lose_during_commit;
     times_to_lose_during_draw_ = kTests[test_case_].times_to_lose_during_draw;
     times_to_fail_recreate_ = kTests[test_case_].times_to_fail_recreate;
     fallback_context_works_ = kTests[test_case_].fallback_context_works;
-    async_output_surface_creation_ =
-        kTests[test_case_].async_output_surface_creation;
+    async_compositor_frame_sink_creation_ =
+        kTests[test_case_].async_compositor_frame_sink_creation;
     ++test_case_;
     return true;
   }
 
   struct TestCase {
     int times_to_lose_during_commit;
     int times_to_lose_during_draw;
     int times_to_fail_recreate;
     bool fallback_context_works;
-    bool async_output_surface_creation;
+    bool async_compositor_frame_sink_creation;
   };
 
  protected:
   size_t test_case_;
   int num_losses_;
   int num_losses_last_test_case_;
   bool recovered_context_;
   bool first_initialized_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostContextTestLostContextSucceeds);
 
-class LayerTreeHostClientNotVisibleDoesNotCreateOutputSurface
+class LayerTreeHostClientNotVisibleDoesNotCreateCompositorFrameSink
     : public LayerTreeHostContextTest {
  public:
-  LayerTreeHostClientNotVisibleDoesNotCreateOutputSurface()
+  LayerTreeHostClientNotVisibleDoesNotCreateCompositorFrameSink()
       : LayerTreeHostContextTest() {}
 
   void WillBeginTest() override {
     // Override to not become visible.
     DCHECK(!layer_tree_host()->IsVisible());
   }
 
   void BeginTest() override {
     PostSetNeedsCommitToMainThread();
     EndTest();
   }
 
-  void RequestNewOutputSurface() override {
-    ADD_FAILURE() << "RequestNewOutputSurface() should not be called";
+  void RequestNewCompositorFrameSink() override {
+    ADD_FAILURE() << "RequestNewCompositorFrameSink() should not be called";
   }
 
-  void DidInitializeOutputSurface() override { EXPECT_TRUE(false); }
+  void DidInitializeCompositorFrameSink() override { EXPECT_TRUE(false); }
 
   void AfterTest() override {}
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
-    LayerTreeHostClientNotVisibleDoesNotCreateOutputSurface);
+    LayerTreeHostClientNotVisibleDoesNotCreateCompositorFrameSink);
 
-// This tests the OutputSurface release logic in the following sequence.
-// SetUp LTH and create and init OutputSurface
+// This tests the CompositorFrameSink release logic in the following sequence.
+// SetUp LTH and create and init CompositorFrameSink.
 // LTH::SetVisible(false);
-// LTH::ReleaseOutputSurface();
+// LTH::ReleaseCompositorFrameSink();
 // ...
 // LTH::SetVisible(true);
-// Create and init new OutputSurface
-class LayerTreeHostClientTakeAwayOutputSurface
+// Create and init new CompositorFrameSink
+class LayerTreeHostClientTakeAwayCompositorFrameSink
     : public LayerTreeHostContextTest {
  public:
-  LayerTreeHostClientTakeAwayOutputSurface()
+  LayerTreeHostClientTakeAwayCompositorFrameSink()
       : LayerTreeHostContextTest(), setos_counter_(0) {}
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  void RequestNewOutputSurface() override {
+  void RequestNewCompositorFrameSink() override {
     if (layer_tree_host()->IsVisible()) {
       setos_counter_++;
-      LayerTreeHostContextTest::RequestNewOutputSurface();
+      LayerTreeHostContextTest::RequestNewCompositorFrameSink();
     }
   }
 
-  void HideAndReleaseOutputSurface() {
+  void HideAndReleaseCompositorFrameSink() {
     EXPECT_TRUE(layer_tree_host()->GetTaskRunnerProvider()->IsMainThread());
     layer_tree_host()->SetVisible(false);
-    std::unique_ptr<OutputSurface> surface =
-        layer_tree_host()->ReleaseOutputSurface();
+    std::unique_ptr<CompositorFrameSink> surface =
+        layer_tree_host()->ReleaseCompositorFrameSink();
     CHECK(surface);
     MainThreadTaskRunner()->PostTask(
         FROM_HERE,
-        base::Bind(&LayerTreeHostClientTakeAwayOutputSurface::MakeVisible,
+        base::Bind(&LayerTreeHostClientTakeAwayCompositorFrameSink::MakeVisible,
                    base::Unretained(this)));
   }
 
-  void DidInitializeOutputSurface() override {
+  void DidInitializeCompositorFrameSink() override {
     EXPECT_TRUE(layer_tree_host()->IsVisible());
     if (setos_counter_ == 1) {
       MainThreadTaskRunner()->PostTask(
-          FROM_HERE, base::Bind(&LayerTreeHostClientTakeAwayOutputSurface::
-                                    HideAndReleaseOutputSurface,
-                                base::Unretained(this)));
+          FROM_HERE,
+          base::Bind(&LayerTreeHostClientTakeAwayCompositorFrameSink::
+                         HideAndReleaseCompositorFrameSink,
+                     base::Unretained(this)));
     } else {
       EndTest();
     }
   }
 
   void MakeVisible() {
     EXPECT_TRUE(layer_tree_host()->GetTaskRunnerProvider()->IsMainThread());
     layer_tree_host()->SetVisible(true);
   }
 
   void AfterTest() override {}
 
   int setos_counter_;
 };
 
-SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostClientTakeAwayOutputSurface);
+SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostClientTakeAwayCompositorFrameSink);
 
-class MultipleCompositeDoesNotCreateOutputSurface
+class MultipleCompositeDoesNotCreateCompositorFrameSink
     : public LayerTreeHostContextTest {
  public:
-  MultipleCompositeDoesNotCreateOutputSurface()
+  MultipleCompositeDoesNotCreateCompositorFrameSink()
       : LayerTreeHostContextTest(), request_count_(0) {}
 
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->single_thread_proxy_scheduler = false;
     settings->use_zero_copy = true;
   }
 
-  void RequestNewOutputSurface() override {
+  void RequestNewCompositorFrameSink() 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));
   }
 
-  void DidInitializeOutputSurface() override { EXPECT_TRUE(false); }
+  void DidInitializeCompositorFrameSink() 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);
+SINGLE_THREAD_TEST_F(MultipleCompositeDoesNotCreateCompositorFrameSink);
 
 // This test makes sure that once a SingleThreadProxy issues a
-// DidFailToInitializeOutputSurface, that future Composite calls will not
+// DidFailToInitializeCompositorFrameSink, that future Composite calls will not
 // trigger additional requests for output surfaces.
-class FailedCreateDoesNotCreateExtraOutputSurface
+class FailedCreateDoesNotCreateExtraCompositorFrameSink
     : public LayerTreeHostContextTest {
  public:
-  FailedCreateDoesNotCreateExtraOutputSurface()
+  FailedCreateDoesNotCreateExtraCompositorFrameSink()
       : LayerTreeHostContextTest(), num_requests_(0), has_failed_(false) {}
 
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->single_thread_proxy_scheduler = false;
     settings->use_zero_copy = true;
   }
 
-  void RequestNewOutputSurface() override {
+  void RequestNewCompositorFrameSink() 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.
+    // the LayerTreeTest test hooks DidFailToInitializeCompositorFrameSink
+    // (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();
+    LayerTreeHostContextTest::RequestNewCompositorFrameSink();
   }
 
-  std::unique_ptr<TestDelegatingOutputSurface> CreateDelegatingOutputSurface(
+  std::unique_ptr<TestCompositorFrameSink> CreateCompositorFrameSink(
       scoped_refptr<ContextProvider> compositor_context_provider,
       scoped_refptr<ContextProvider> worker_context_provider) override {
     ExpectCreateToFail();
     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(
+    return LayerTreeTest::CreateCompositorFrameSink(
         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));
     EXPECT_EQ(num_requests_, 2);
     EndTest();
   }
 
-  void DidInitializeOutputSurface() override { EXPECT_TRUE(false); }
+  void DidInitializeCompositorFrameSink() override { EXPECT_TRUE(false); }
 
-  void DidFailToInitializeOutputSurface() override {
-    LayerTreeHostContextTest::DidFailToInitializeOutputSurface();
+  void DidFailToInitializeCompositorFrameSink() override {
+    LayerTreeHostContextTest::DidFailToInitializeCompositorFrameSink();
     EXPECT_FALSE(has_failed_);
     has_failed_ = true;
   }
 
   void AfterTest() override {}
 
   int num_requests_;
   bool has_failed_;
 };
 
 // This test uses Composite() which only exists for single thread.
-SINGLE_THREAD_TEST_F(FailedCreateDoesNotCreateExtraOutputSurface);
+SINGLE_THREAD_TEST_F(FailedCreateDoesNotCreateExtraCompositorFrameSink);
 
-class LayerTreeHostContextTestCommitAfterDelayedOutputSurface
+class LayerTreeHostContextTestCommitAfterDelayedCompositorFrameSink
     : public LayerTreeHostContextTest {
  public:
-  LayerTreeHostContextTestCommitAfterDelayedOutputSurface()
+  LayerTreeHostContextTestCommitAfterDelayedCompositorFrameSink()
       : LayerTreeHostContextTest(), creating_output_(false) {}
 
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->single_thread_proxy_scheduler = false;
     settings->use_zero_copy = true;
   }
 
-  void RequestNewOutputSurface() override {
+  void RequestNewCompositorFrameSink() override {
     MainThreadTaskRunner()->PostTask(
         FROM_HERE,
-        base::Bind(&LayerTreeHostContextTestCommitAfterDelayedOutputSurface::
-                       CreateAndSetOutputSurface,
-                   base::Unretained(this)));
+        base::Bind(
+            &LayerTreeHostContextTestCommitAfterDelayedCompositorFrameSink::
+                CreateAndSetCompositorFrameSink,
+            base::Unretained(this)));
   }
 
-  void CreateAndSetOutputSurface() {
+  void CreateAndSetCompositorFrameSink() {
     creating_output_ = true;
-    LayerTreeHostContextTest::RequestNewOutputSurface();
+    LayerTreeHostContextTest::RequestNewCompositorFrameSink();
   }
 
   void BeginTest() override {
     layer_tree_host()->Composite(base::TimeTicks::FromInternalValue(1));
   }
 
   void ScheduleComposite() override {
     if (creating_output_)
       EndTest();
   }
 
   void AfterTest() override {}
 
   bool creating_output_;
 };
 
 // This test uses Composite() which only exists for single thread.
-SINGLE_THREAD_TEST_F(LayerTreeHostContextTestCommitAfterDelayedOutputSurface);
+SINGLE_THREAD_TEST_F(
+    LayerTreeHostContextTestCommitAfterDelayedCompositorFrameSink);
 
 class LayerTreeHostContextTestAvoidUnnecessaryComposite
     : public LayerTreeHostContextTest {
  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 {
-    LayerTreeHostContextTest::RequestNewOutputSurface();
+  void RequestNewCompositorFrameSink() override {
+    LayerTreeHostContextTest::RequestNewCompositorFrameSink();
     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 50 matching lines @@
 
  protected:
   FakeContentLayerClient client_;
   scoped_refptr<Layer> root_;
   scoped_refptr<Layer> layer_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostContextTestLostContextSucceedsWithContent);
 
-class LayerTreeHostContextTestCreateOutputSurfaceFailsOnce
+class LayerTreeHostContextTestCreateCompositorFrameSinkFailsOnce
     : public LayerTreeHostContextTest {
  public:
-  LayerTreeHostContextTestCreateOutputSurfaceFailsOnce()
+  LayerTreeHostContextTestCreateCompositorFrameSinkFailsOnce()
       : times_to_fail_(1), times_initialized_(0) {
     times_to_fail_create_ = times_to_fail_;
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  void DidInitializeOutputSurface() override { times_initialized_++; }
+  void DidInitializeCompositorFrameSink() override { times_initialized_++; }
 
   void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override { EndTest(); }
 
   void AfterTest() override {
     EXPECT_EQ(times_to_fail_, times_create_failed_);
     EXPECT_NE(0, times_initialized_);
   }
 
  private:
   int times_to_fail_;
   int times_initialized_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
-    LayerTreeHostContextTestCreateOutputSurfaceFailsOnce);
+    LayerTreeHostContextTestCreateCompositorFrameSinkFailsOnce);
 
 class LayerTreeHostContextTestLostContextAndEvictTextures
     : public LayerTreeHostContextTest {
  public:
   LayerTreeHostContextTestLostContextAndEvictTextures()
       : LayerTreeHostContextTest(),
         impl_host_(0),
         num_commits_(0),
         lost_context_(false) {}
 
@@ skipping 59 matching lines @@
     EXPECT_TRUE(picture_impl->HighResTiling()
                     ->TileAt(0, 0)
                     ->draw_info()
                     .IsReadyToDraw());
 
     impl_host_ = impl;
     if (lost_context_)
       EndTest();
   }
 
-  void DidInitializeOutputSurface() override {}
+  void DidInitializeCompositorFrameSink() override {}
 
   void AfterTest() override {}
 
  protected:
   bool lose_after_evict_;
   FakeContentLayerClient client_;
   LayerTreeHostImpl* impl_host_;
   int num_commits_;
   bool lost_context_;
 };
@@ skipping 91 matching lines @@
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostContextTestLayersNotified);
 
 class LayerTreeHostContextTestDontUseLostResources
     : public LayerTreeHostContextTest {
  public:
   LayerTreeHostContextTestDontUseLostResources() : lost_context_(false) {
     context_should_support_io_surface_ = true;
 
-    child_output_surface_ = FakeOutputSurface::CreateDelegating3d();
-    child_output_surface_->BindToClient(&output_surface_client_);
-    shared_bitmap_manager_.reset(new TestSharedBitmapManager());
+    child_context_provider_ = TestContextProvider::Create();
+    CHECK(child_context_provider_->BindToCurrentThread());
+    shared_bitmap_manager_.reset(new TestSharedBitmapManager);
     child_resource_provider_ = FakeResourceProvider::Create(
-        child_output_surface_.get(), shared_bitmap_manager_.get());
+        child_context_provider_.get(), shared_bitmap_manager_.get());
   }
 
   static void EmptyReleaseCallback(const gpu::SyncToken& sync_token,
                                    bool lost) {}
 
   void SetupTree() override {
-    gpu::gles2::GLES2Interface* gl =
-        child_output_surface_->context_provider()->ContextGL();
+    gpu::gles2::GLES2Interface* gl = child_context_provider_->ContextGL();
 
     std::unique_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData);
 
     std::unique_ptr<RenderPass> pass_for_quad = RenderPass::Create();
     pass_for_quad->SetNew(
         // AppendOneOfEveryQuadType() makes a RenderPass quad with this id.
         RenderPassId(2, 1),
         gfx::Rect(0, 0, 10, 10),
         gfx::Rect(0, 0, 10, 10),
         gfx::Transform());
@@ skipping 127 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;
   }
 
-  void RequestNewOutputSurface() override {
+  void RequestNewCompositorFrameSink() override {
     // This will get called twice:
-    // First when we create the initial output surface...
+    // First when we create the initial CompositorFrameSink...
     if (layer_tree_host()->SourceFrameNumber() > 0) {
       // ... and then again after we forced the context to be lost.
       lost_context_ = true;
     }
-    LayerTreeHostContextTest::RequestNewOutputSurface();
+    LayerTreeHostContextTest::RequestNewCompositorFrameSink();
   }
 
   void DidCommitAndDrawFrame() override {
     ASSERT_TRUE(layer_tree()->hud_layer());
     // End the test once we know the 3nd frame drew.
     if (layer_tree_host()->SourceFrameNumber() < 5) {
       layer_tree()->root_layer()->SetNeedsDisplay();
       layer_tree_host()->SetNeedsCommit();
     } else {
       EndTest();
     }
   }
 
   void AfterTest() override { EXPECT_TRUE(lost_context_); }
 
  private:
   FakeContentLayerClient client_;
   bool lost_context_;
 
-  FakeOutputSurfaceClient output_surface_client_;
-  std::unique_ptr<FakeOutputSurface> child_output_surface_;
+  scoped_refptr<TestContextProvider> child_context_provider_;
   std::unique_ptr<SharedBitmapManager> shared_bitmap_manager_;
   std::unique_ptr<ResourceProvider> child_resource_provider_;
 
   scoped_refptr<VideoFrame> color_video_frame_;
   scoped_refptr<VideoFrame> hw_video_frame_;
   scoped_refptr<VideoFrame> scaled_hw_video_frame_;
 
   FakeVideoFrameProvider color_frame_provider_;
   FakeVideoFrameProvider hw_frame_provider_;
   FakeVideoFrameProvider scaled_hw_frame_provider_;
@@ skipping 19 matching lines @@
     LayerTreeHostContextTest::SetupTree();
   }
 
   void BeginTest() override {
     times_to_lose_during_commit_ = 1;
     PostSetNeedsCommitToMainThread();
   }
 
   void AfterTest() override {}
 
-  void DidInitializeOutputSurface() override { EndTest(); }
+  void DidInitializeCompositorFrameSink() override { EndTest(); }
 
  private:
   FakeContentLayerClient client_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostContextTestImplSidePainting);
 
 class ScrollbarLayerLostContext : public LayerTreeHostContextTest {
  public:
   ScrollbarLayerLostContext() : commits_(0) {}
@@ skipping 472 matching lines @@
     layer_tree_host()->SetDeferCommits(true);
     // Meanwhile, lose the context while we are in defer commits.
     ImplThreadTaskRunner()->PostTask(
         FROM_HERE,
         base::Bind(&LayerTreeHostContextTestLoseAfterSendingBeginMainFrame::
                        LoseContextOnImplThread,
                    base::Unretained(this)));
 
     // After the first frame, we will lose the context and then not start
     // allowing commits until that happens. The 2nd frame should not happen
-    // before DidInitializeOutputSurface occurs.
+    // before DidInitializeCompositorFrameSink occurs.
     lost_ = true;
   }
 
-  void DidInitializeOutputSurface() override {
+  void DidInitializeCompositorFrameSink() override {
     EXPECT_TRUE(lost_);
     lost_ = false;
   }
 
   void LoseContextOnImplThread() {
     LoseContext();
 
     // After losing the context, stop deferring commits.
     PostSetDeferCommitsToMainThread(false);
   }
 
   void DidCommitAndDrawFrame() override { EndTest(); }
 
   void AfterTest() override {}
 
   bool deferred_ = false;
   bool lost_ = true;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostContextTestLoseAfterSendingBeginMainFrame);
 
 }  // namespace
 }  // namespace cc