Move output surface fallback from cc to embedders

cc/layers/tiled_layer_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/layers/tiled_layer.h"
 
 #include <limits>
 #include <vector>
 
 #include "base/run_loop.h"
@@ skipping 27 matching lines @@
 
   void SetRenderTarget(Layer* render_target) {
     stack_.back().target = render_target;
   }
 
   void SetOcclusion(const SimpleEnclosedRegion& occlusion) {
     stack_.back().occlusion_from_inside_target = occlusion;
   }
 };
 
-class SynchronousOutputSurfaceLayerTreeHost : public LayerTreeHost {
+class SynchronousOutputSurfaceClient : public FakeLayerTreeHostClient {
  public:
-  static scoped_ptr<SynchronousOutputSurfaceLayerTreeHost> Create(
-      LayerTreeHostClient* client,
-      SharedBitmapManager* manager,
-      const LayerTreeSettings& settings,
-      scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner) {
-    return make_scoped_ptr(new SynchronousOutputSurfaceLayerTreeHost(
-        client, manager, settings, impl_task_runner));
-  }
-
-  ~SynchronousOutputSurfaceLayerTreeHost() override {}
+  SynchronousOutputSurfaceClient()
+      : FakeLayerTreeHostClient(FakeLayerTreeHostClient::DIRECT_3D) {}
 
   bool EnsureOutputSurfaceCreated() {
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         run_loop_.QuitClosure(),
         base::TimeDelta::FromSeconds(5));
     run_loop_.Run();
     return output_surface_created_;
   }
 
-  void OnCreateAndInitializeOutputSurfaceAttempted(bool success) override {
-    LayerTreeHost::OnCreateAndInitializeOutputSurfaceAttempted(success);
-    output_surface_created_ = success;
+  void DidInitializeOutputSurface() override {
+    FakeLayerTreeHostClient::DidInitializeOutputSurface();
+    output_surface_created_ = true;
+    run_loop_.Quit();
+  }
+
+  void DidFailToInitializeOutputSurface() override {
+    FakeLayerTreeHostClient::DidFailToInitializeOutputSurface();
+    output_surface_created_ = false;
     run_loop_.Quit();
   }
 
  private:
-  SynchronousOutputSurfaceLayerTreeHost(
-      LayerTreeHostClient* client,
-      SharedBitmapManager* manager,
-      const LayerTreeSettings& settings,
-      scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner)
-      : LayerTreeHost(client, manager, NULL, settings),
-        output_surface_created_(false) {
-    LayerTreeHost::InitializeThreaded(base::MessageLoopProxy::current(),
-                                      impl_task_runner,
-                                      nullptr);
-  }
-
   bool output_surface_created_;
   base::RunLoop run_loop_;
 };
 
 class TiledLayerTest : public testing::Test {
  public:
   TiledLayerTest()
       : proxy_(nullptr),
         output_surface_(FakeOutputSurface::Create3d()),
         queue_(make_scoped_ptr(new ResourceUpdateQueue)),
         impl_thread_("ImplThread"),
-        fake_layer_tree_host_client_(FakeLayerTreeHostClient::DIRECT_3D),
         occlusion_(nullptr) {
     settings_.max_partial_texture_updates = std::numeric_limits<size_t>::max();
     settings_.layer_transforms_should_scale_layer_contents = true;
   }
 
   void SetUp() override {
     impl_thread_.Start();
     shared_bitmap_manager_.reset(new TestSharedBitmapManager());
-    layer_tree_host_ = SynchronousOutputSurfaceLayerTreeHost::Create(
-        &fake_layer_tree_host_client_,
-        shared_bitmap_manager_.get(),
-        settings_,
-        impl_thread_.message_loop_proxy());
-    fake_layer_tree_host_client_.SetLayerTreeHost(layer_tree_host_.get());
+    layer_tree_host_ = LayerTreeHost::CreateThreaded(
+        &synchonous_output_surface_client_, shared_bitmap_manager_.get(),
+        nullptr, settings_, base::MessageLoopProxy::current(),
+        impl_thread_.message_loop_proxy(), nullptr);
+    synchonous_output_surface_client_.SetLayerTreeHost(layer_tree_host_.get());
     proxy_ = layer_tree_host_->proxy();
     resource_manager_ = PrioritizedResourceManager::Create(proxy_);
     layer_tree_host_->SetLayerTreeHostClientReady();
-    CHECK(layer_tree_host_->EnsureOutputSurfaceCreated());
+    CHECK(synchonous_output_surface_client_.EnsureOutputSurfaceCreated());
+
     layer_tree_host_->SetRootLayer(Layer::Create());
 
     CHECK(output_surface_->BindToClient(&output_surface_client_));
 
     DebugScopedSetImplThreadAndMainThreadBlocked
         impl_thread_and_main_thread_blocked(proxy_);
     resource_provider_ = ResourceProvider::Create(output_surface_.get(),
                                                   shared_bitmap_manager_.get(),
                                                   nullptr,
                                                   nullptr,
@@ skipping 117 matching lines @@
  public:
   Proxy* proxy_;
   LayerTreeSettings settings_;
   FakeOutputSurfaceClient output_surface_client_;
   scoped_ptr<OutputSurface> output_surface_;
   scoped_ptr<SharedBitmapManager> shared_bitmap_manager_;
   scoped_ptr<ResourceProvider> resource_provider_;
   scoped_ptr<ResourceUpdateQueue> queue_;
   PriorityCalculator priority_calculator_;
   base::Thread impl_thread_;
-  FakeLayerTreeHostClient fake_layer_tree_host_client_;
-  scoped_ptr<SynchronousOutputSurfaceLayerTreeHost> layer_tree_host_;
+  SynchronousOutputSurfaceClient synchonous_output_surface_client_;
+  scoped_ptr<LayerTreeHost> layer_tree_host_;
   scoped_ptr<FakeLayerTreeHostImpl> host_impl_;
   scoped_ptr<PrioritizedResourceManager> resource_manager_;
   TestOcclusionTracker* occlusion_;
 };
 
 TEST_F(TiledLayerTest, PushDirtyTiles) {
   layer_tree_host_->SetViewportSize(gfx::Size(1000, 1000));
 
   scoped_refptr<FakeTiledLayer> layer =
       make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
@@ skipping 1492 matching lines @@
 
   // Rounding leads to an extra pixel.
   gfx::Rect expanded_layer_rect(layer_rect);
   expanded_layer_rect.set_height(32);
   EXPECT_EQ(expanded_layer_rect,
             layer->tracking_layer_painter()->PaintedRect());
 }
 
 }  // namespace
 }  // namespace cc