Move output surface fallback from cc to embedders

cc/trees/layer_tree_host_unittest.cc

 // Copyright 2011 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 "cc/trees/layer_tree_host.h"
 
 #include <algorithm>
 
 #include "base/auto_reset.h"
 #include "base/synchronization/lock.h"
@@ skipping 2075 matching lines @@
     FakeLayerTreeHostClient client(FakeLayerTreeHostClient::DIRECT_3D);
 
     scoped_ptr<FakeProxy> proxy(new FakeProxy);
     proxy->GetRendererCapabilities().allow_partial_texture_updates = false;
     proxy->SetMaxPartialTextureUpdates(5);
 
     LayerTreeSettings settings;
     settings.max_partial_texture_updates = 10;
 
     LayerTreeHostWithProxy host(&client, settings, proxy.Pass());
-    host.OnCreateAndInitializeOutputSurfaceAttempted(true);
 
     EXPECT_EQ(0u, host.MaxPartialTextureUpdates());
   }
 
   // When partial updates are allowed,
   // max updates should be limited by the proxy.
   {
     FakeLayerTreeHostClient client(FakeLayerTreeHostClient::DIRECT_3D);
 
     scoped_ptr<FakeProxy> proxy(new FakeProxy);
     proxy->GetRendererCapabilities().allow_partial_texture_updates = true;
     proxy->SetMaxPartialTextureUpdates(5);
 
     LayerTreeSettings settings;
     settings.max_partial_texture_updates = 10;
 
     LayerTreeHostWithProxy host(&client, settings, proxy.Pass());
-    host.OnCreateAndInitializeOutputSurfaceAttempted(true);
 
     EXPECT_EQ(5u, host.MaxPartialTextureUpdates());
   }
 
   // When partial updates are allowed,
   // max updates should also be limited by the settings.
   {
     FakeLayerTreeHostClient client(FakeLayerTreeHostClient::DIRECT_3D);
 
     scoped_ptr<FakeProxy> proxy(new FakeProxy);
     proxy->GetRendererCapabilities().allow_partial_texture_updates = true;
     proxy->SetMaxPartialTextureUpdates(20);
 
     LayerTreeSettings settings;
     settings.max_partial_texture_updates = 10;
 
     LayerTreeHostWithProxy host(&client, settings, proxy.Pass());
-    host.OnCreateAndInitializeOutputSurfaceAttempted(true);
 
     EXPECT_EQ(10u, host.MaxPartialTextureUpdates());
   }
 }
 
 TEST(LayerTreeHostTest, PartialUpdatesWithGLRenderer) {
   FakeLayerTreeHostClient client(FakeLayerTreeHostClient::DIRECT_3D);
 
   LayerTreeSettings settings;
   settings.max_partial_texture_updates = 4;
@@ skipping 541 matching lines @@
                                   GLsizei count,
                                   GLenum type,
                                   GLintptr offset));
   MOCK_METHOD1(deleteTexture, void(GLenum texture));
   MOCK_METHOD2(produceTextureCHROMIUM,
                void(GLenum target, const GLbyte* mailbox));
 };
 
 class LayerTreeHostTestIOSurfaceDrawing : public LayerTreeHostTest {
  protected:
-  scoped_ptr<FakeOutputSurface> CreateFakeOutputSurface(
-      bool fallback) override {
+  scoped_ptr<FakeOutputSurface> CreateFakeOutputSurface() override {
     scoped_ptr<MockIOSurfaceWebGraphicsContext3D> mock_context_owned(
         new MockIOSurfaceWebGraphicsContext3D);
     mock_context_ = mock_context_owned.get();
 
     if (delegating_renderer())
       return FakeOutputSurface::CreateDelegating3d(mock_context_owned.Pass());
     else
       return FakeOutputSurface::Create3d(mock_context_owned.Pass());
   }
 
@@ skipping 173 matching lines @@
     LayerTreeHostTest::SetupTree();
   }
 
   void BeginTest() override {
     did_initialize_gl_ = false;
     did_release_gl_ = false;
     last_source_frame_number_drawn_ = -1;  // Never drawn.
     PostSetNeedsCommitToMainThread();
   }
 
-  scoped_ptr<FakeOutputSurface> CreateFakeOutputSurface(
-      bool fallback) override {
+  scoped_ptr<FakeOutputSurface> CreateFakeOutputSurface() override {
     scoped_ptr<TestWebGraphicsContext3D> context3d(
         TestWebGraphicsContext3D::Create());
 
     return FakeOutputSurface::CreateDeferredGL(
         scoped_ptr<SoftwareOutputDevice>(new SoftwareOutputDevice),
         delegating_renderer());
   }
 
   void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override {
     ASSERT_TRUE(host_impl->RootLayer());
@@ skipping 1497 matching lines @@
 MULTI_THREAD_TEST_F(LayerTreeHostTestAbortEvictedTextures);
 
 class LayerTreeHostTestMaxTransferBufferUsageBytes : public LayerTreeHostTest {
  protected:
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->impl_side_painting = true;
     settings->use_zero_copy = false;
     settings->use_one_copy = false;
   }
 
-  scoped_ptr<FakeOutputSurface> CreateFakeOutputSurface(
-      bool fallback) override {
+  scoped_ptr<FakeOutputSurface> CreateFakeOutputSurface() override {
     scoped_refptr<TestContextProvider> context_provider =
         TestContextProvider::Create();
     context_provider->SetMaxTransferBufferUsageBytes(512 * 512);
     if (delegating_renderer())
       return FakeOutputSurface::CreateDelegating3d(context_provider);
     else
       return FakeOutputSurface::Create3d(context_provider);
   }
 
   void SetupTree() override {
@@ skipping 120 matching lines @@
 
 }  // namespace
 
 class LayerTreeHostTestSetMemoryPolicyOnLostOutputSurface
     : public LayerTreeHostTest {
  protected:
   LayerTreeHostTestSetMemoryPolicyOnLostOutputSurface()
       : first_output_surface_memory_limit_(4321234),
         second_output_surface_memory_limit_(1234321) {}
 
-  scoped_ptr<FakeOutputSurface> CreateFakeOutputSurface(
-      bool fallback) override {
+  scoped_ptr<FakeOutputSurface> CreateFakeOutputSurface() override {
     if (!first_context_provider_.get()) {
       first_context_provider_ = TestContextProvider::Create();
     } else {
       EXPECT_FALSE(second_context_provider_.get());
       second_context_provider_ = TestContextProvider::Create();
     }
 
     scoped_refptr<TestContextProvider> provider(second_context_provider_.get()
                                                     ? second_context_provider_
                                                     : first_context_provider_);
@@ skipping 244 matching lines @@
                                      bool did_handle) override {
     EndTest();
     // This lets the test finally commit and exit.
     MainThreadTaskRunner()->PostTask(
         FROM_HERE,
         base::Bind(&LayerTreeHostTestBreakSwapPromiseForContextAbortedCommit::
                        FindOutputSurface,
                    base::Unretained(this)));
   }
 
-  void FindOutputSurface() {
-    layer_tree_host()->OnCreateAndInitializeOutputSurfaceAttempted(true);
-  }
+  void FindOutputSurface() { layer_tree_host()->DidInitializeOutputSurface(); }
 
   void AfterTest() override {
     {
       base::AutoLock lock(swap_promise_result_.lock);
       EXPECT_FALSE(swap_promise_result_.did_swap_called);
       EXPECT_TRUE(swap_promise_result_.did_not_swap_called);
       EXPECT_EQ(SwapPromise::COMMIT_FAILS, swap_promise_result_.reason);
       EXPECT_TRUE(swap_promise_result_.dtor_called);
     }
   }
@@ skipping 855 matching lines @@
 
 MULTI_THREAD_IMPL_TEST_F(LayerTreeHostTestCrispUpAfterPinchEnds);
 
 class LayerTreeHostTestCrispUpAfterPinchEndsWithOneCopy
     : public LayerTreeHostTestCrispUpAfterPinchEnds {
  protected:
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->use_one_copy = true;
   }
 
-  scoped_ptr<FakeOutputSurface> CreateFakeOutputSurface(
-      bool fallback) override {
+  scoped_ptr<FakeOutputSurface> CreateFakeOutputSurface() override {
     scoped_ptr<TestWebGraphicsContext3D> context3d =
         TestWebGraphicsContext3D::Create();
     context3d->set_support_image(true);
     context3d->set_support_sync_query(true);
 #if defined(OS_MACOSX)
     context3d->set_support_texture_rectangle(true);
 #endif
 
     if (delegating_renderer())
       return FakeOutputSurface::CreateDelegating3d(context3d.Pass());
@@ skipping 175 matching lines @@
 
   FakeContentLayerClient client_;
   int step_;
   int continuous_draws_;
   base::WaitableEvent playback_allowed_event_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestContinuousDrawWhenCreatingVisibleTiles);
 
 }  // namespace cc