Move output surface fallback from cc to embedders

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 "cc/trees/layer_tree_host.h"
 
 #include "base/basictypes.h"
 #include "cc/layers/content_layer.h"
 #include "cc/layers/delegated_frame_provider.h"
 #include "cc/layers/delegated_frame_resource_collection.h"
 #include "cc/layers/heads_up_display_layer.h"
 #include "cc/layers/io_surface_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.h"
 #include "cc/test/fake_content_layer_client.h"
 #include "cc/test/fake_content_layer_impl.h"
 #include "cc/test/fake_delegated_renderer_layer.h"
 #include "cc/test/fake_delegated_renderer_layer_impl.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"
@@ skipping 42 matching lines @@
     CHECK(context3d_);
     context3d_->loseContextCHROMIUM(GL_GUILTY_CONTEXT_RESET_ARB,
                                     GL_INNOCENT_CONTEXT_RESET_ARB);
     context3d_ = NULL;
   }
 
   virtual scoped_ptr<TestWebGraphicsContext3D> CreateContext3d() {
     return TestWebGraphicsContext3D::Create();
   }
 
-  scoped_ptr<FakeOutputSurface> CreateFakeOutputSurface(
-      bool fallback) override {
+  scoped_ptr<FakeOutputSurface> CreateFakeOutputSurface() override {
     if (times_to_fail_create_) {
       --times_to_fail_create_;
       ExpectCreateToFail();
-      return nullptr;
+      return make_scoped_ptr(new FailureOutputSurface(delegating_renderer()));
     }
 
     scoped_ptr<TestWebGraphicsContext3D> context3d = CreateContext3d();
     context3d_ = context3d.get();
 
     if (context_should_support_io_surface_) {
       context3d_->set_have_extension_io_surface(true);
       context3d_->set_have_extension_egl_image(true);
     }
 
@@ skipping 67 matching lines @@
   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(bool fallback) override {
+  void RequestNewOutputSurface() override {
     if (async_output_surface_creation_) {
       MainThreadTaskRunner()->PostTask(
-          FROM_HERE,
-          base::Bind(&LayerTreeHostContextTestLostContextSucceeds::
-                         CreateAndSetOutputSurface,
-                     base::Unretained(this),
-                     fallback));
+          FROM_HERE, base::Bind(&LayerTreeHostContextTestLostContextSucceeds::
+                                    CreateAndSetOutputSurface,
+                                base::Unretained(this)));
     } else {
-      CreateAndSetOutputSurface(fallback);
+      CreateAndSetOutputSurface();
     }
   }
 
-  void CreateAndSetOutputSurface(bool fallback) {
-    layer_tree_host()->SetOutputSurface(
-        LayerTreeHostContextTest::CreateOutputSurface(fallback));
+  void CreateAndSetOutputSurface() {
+    scoped_ptr<OutputSurface> surface(
+        LayerTreeHostContextTest::CreateOutputSurface());
+    CHECK(surface);
+    layer_tree_host()->SetOutputSurface(surface.Pass());
   }
 
   void DidInitializeOutputSurface() override {
     if (first_initialized_)
       ++num_losses_;
     else
       first_initialized_ = true;
 
     recovered_context_ = true;
   }
@@ skipping 154 matching lines @@
 
   void WillBeginTest() override {
     // Override and do not signal SetLayerTreeHostClientReady.
   }
 
   void BeginTest() override {
     PostSetNeedsCommitToMainThread();
     EndTest();
   }
 
-  scoped_ptr<OutputSurface> CreateOutputSurface(bool fallback) override {
+  scoped_ptr<OutputSurface> CreateOutputSurface() override {
     EXPECT_TRUE(false);
     return nullptr;
   }
 
   void DidInitializeOutputSurface() override { EXPECT_TRUE(false); }
 
   void AfterTest() override {}
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostClientNotReadyDoesNotCreateOutputSurface);
 
 class MultipleCompositeDoesNotCreateOutputSurface
     : public LayerTreeHostContextTest {
  public:
   MultipleCompositeDoesNotCreateOutputSurface()
       : LayerTreeHostContextTest(), request_count_(0) {}
 
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->single_thread_proxy_scheduler = false;
   }
 
-  void RequestNewOutputSurface(bool fallback) override {
+  void RequestNewOutputSurface() override {
     EXPECT_GE(1, ++request_count_);
     EndTest();
   }
 
   void BeginTest() override {
     layer_tree_host()->Composite(base::TimeTicks());
     layer_tree_host()->Composite(base::TimeTicks());
   }
 
-  scoped_ptr<OutputSurface> CreateOutputSurface(bool fallback) override {
+  scoped_ptr<OutputSurface> CreateOutputSurface() override {
     EXPECT_TRUE(false);
     return nullptr;
   }
 
   void DidInitializeOutputSurface() override { EXPECT_TRUE(false); }
 
   void AfterTest() override {}
 
   int request_count_;
 };
 
 SINGLE_THREAD_NOIMPL_TEST_F(MultipleCompositeDoesNotCreateOutputSurface);
 
 class FailedCreateDoesNotCreateExtraOutputSurface
     : public LayerTreeHostContextTest {
  public:
   FailedCreateDoesNotCreateExtraOutputSurface()
       : LayerTreeHostContextTest(), request_count_(0) {}
 
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->single_thread_proxy_scheduler = false;
   }
 
-  void RequestNewOutputSurface(bool fallback) override {
+  void RequestNewOutputSurface() override {
     if (request_count_ == 0) {
       ExpectCreateToFail();
-      layer_tree_host()->SetOutputSurface(nullptr);
+      layer_tree_host()->SetOutputSurface(
+          make_scoped_ptr(new FailureOutputSurface(false)));
     }
-    EXPECT_GE(2, ++request_count_);
-    EndTest();
   }
 
   void BeginTest() override {
     layer_tree_host()->Composite(base::TimeTicks());
     layer_tree_host()->Composite(base::TimeTicks());
   }
 
-  scoped_ptr<OutputSurface> CreateOutputSurface(bool fallback) override {
-    EXPECT_TRUE(false);
-    return nullptr;
-  }
-
   void DidInitializeOutputSurface() override { EXPECT_TRUE(false); }
 
+  void DidFailToInitializeOutputSurface() override {
+    LayerTreeHostContextTest::DidFailToInitializeOutputSurface();
+    EXPECT_GE(2, ++request_count_);
+    EndTest();
+  }
+
   void AfterTest() override {}
 
   int request_count_;
 };
 
 SINGLE_THREAD_NOIMPL_TEST_F(FailedCreateDoesNotCreateExtraOutputSurface);
 
 class LayerTreeHostContextTestCommitAfterDelayedOutputSurface
     : public LayerTreeHostContextTest {
  public:
   LayerTreeHostContextTestCommitAfterDelayedOutputSurface()
       : LayerTreeHostContextTest(), creating_output_(false) {}
 
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->single_thread_proxy_scheduler = false;
   }
 
-  void RequestNewOutputSurface(bool fallback) override {
+  void RequestNewOutputSurface() override {
     MainThreadTaskRunner()->PostTask(
         FROM_HERE,
         base::Bind(&LayerTreeHostContextTestCommitAfterDelayedOutputSurface::
                        CreateAndSetOutputSurface,
-                   base::Unretained(this),
-                   fallback));
+                   base::Unretained(this)));
   }
 
-  void CreateAndSetOutputSurface(bool fallback) {
+  void CreateAndSetOutputSurface() {
     creating_output_ = true;
     layer_tree_host()->SetOutputSurface(
-        LayerTreeHostContextTest::CreateOutputSurface(fallback));
+        LayerTreeHostContextTest::CreateOutputSurface());
   }
 
   void BeginTest() override { layer_tree_host()->Composite(base::TimeTicks()); }
 
   void ScheduleComposite() override {
     if (creating_output_)
       EndTest();
   }
 
   void AfterTest() override {}
 
   bool creating_output_;
 };
 
 SINGLE_THREAD_NOIMPL_TEST_F(
     LayerTreeHostContextTestCommitAfterDelayedOutputSurface);
 
 class LayerTreeHostContextTestAvoidUnnecessaryComposite
     : public LayerTreeHostContextTest {
  public:
   LayerTreeHostContextTestAvoidUnnecessaryComposite()
       : LayerTreeHostContextTest(), in_composite_(false) {}
 
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->single_thread_proxy_scheduler = false;
   }
 
-  void RequestNewOutputSurface(bool fallback) override {
+  void RequestNewOutputSurface() override {
     layer_tree_host()->SetOutputSurface(
-        LayerTreeHostContextTest::CreateOutputSurface(fallback));
+        LayerTreeHostContextTest::CreateOutputSurface());
     EndTest();
   }
 
   void BeginTest() override {
     in_composite_ = true;
     layer_tree_host()->Composite(base::TimeTicks());
     in_composite_ = false;
   }
 
   void ScheduleComposite() override { EXPECT_FALSE(in_composite_); }
@@ skipping 57 matching lines @@
  protected:
   FakeContentLayerClient client_;
   scoped_refptr<Layer> root_;
   scoped_refptr<Layer> layer_;
 };
 
 // This test uses TiledLayer and PictureLayer to check for a working context.
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostContextTestLostContextSucceedsWithContent);
 
-class LayerTreeHostContextTestCreateOutputSurfaceFails
+class LayerTreeHostContextTestCreateOutputSurfaceFailsOnce
     : public LayerTreeHostContextTest {
  public:
-  // Run a test that initially fails OutputSurface creation |times_to_fail|
-  // times. If |expect_fallback_attempt| is |true|, an attempt to create a
-  // fallback/software OutputSurface is expected to occur.
-  LayerTreeHostContextTestCreateOutputSurfaceFails(int times_to_fail,
-                                                   bool expect_fallback_attempt)
-      : times_to_fail_(times_to_fail),
-        expect_fallback_attempt_(expect_fallback_attempt),
-        did_attempt_fallback_(false),
-        times_initialized_(0) {
+  LayerTreeHostContextTestCreateOutputSurfaceFailsOnce()
+      : times_to_fail_(1), times_initialized_(0) {
     times_to_fail_create_ = times_to_fail_;
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  scoped_ptr<FakeOutputSurface> CreateFakeOutputSurface(
-      bool fallback) override {
-    scoped_ptr<FakeOutputSurface> surface =
-        LayerTreeHostContextTest::CreateFakeOutputSurface(fallback);
-
-    if (surface)
-      EXPECT_EQ(times_to_fail_, times_create_failed_);
-
-    did_attempt_fallback_ = fallback;
-    return surface.Pass();
-  }
-
   void DidInitializeOutputSurface() 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_);
-    EXPECT_EQ(expect_fallback_attempt_, did_attempt_fallback_);
   }
 
  private:
   int times_to_fail_;
-  bool expect_fallback_attempt_;
-  bool did_attempt_fallback_;
   int times_initialized_;
 };
 
-class LayerTreeHostContextTestCreateOutputSurfaceFailsOnce
-    : public LayerTreeHostContextTestCreateOutputSurfaceFails {
- public:
-  LayerTreeHostContextTestCreateOutputSurfaceFailsOnce()
-      : LayerTreeHostContextTestCreateOutputSurfaceFails(1, false) {}
-};
-
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostContextTestCreateOutputSurfaceFailsOnce);
 
-// After 4 failures we expect an attempt to create a fallback/software
-// OutputSurface.
-class LayerTreeHostContextTestCreateOutputSurfaceFailsWithFallback
-    : public LayerTreeHostContextTestCreateOutputSurfaceFails {
- public:
-  LayerTreeHostContextTestCreateOutputSurfaceFailsWithFallback()
-      : LayerTreeHostContextTestCreateOutputSurfaceFails(4, true) {}
-};
-
-SINGLE_AND_MULTI_THREAD_TEST_F(
-    LayerTreeHostContextTestCreateOutputSurfaceFailsWithFallback);
-
 class LayerTreeHostContextTestLostContextAndEvictTextures
     : public LayerTreeHostContextTest {
  public:
   LayerTreeHostContextTestLostContextAndEvictTextures()
       : LayerTreeHostContextTest(),
         impl_host_(0),
         num_commits_(0),
         lost_context_(false) {}
 
   void SetupTree() override {
@@ skipping 509 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;
   }
 
-  scoped_ptr<FakeOutputSurface> CreateFakeOutputSurface(
-      bool fallback) override {
+  scoped_ptr<FakeOutputSurface> CreateFakeOutputSurface() 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::CreateFakeOutputSurface(fallback);
+    return LayerTreeHostContextTest::CreateFakeOutputSurface();
   }
 
   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 645 matching lines @@
   void AfterTest() override {}
 
   bool deferred_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostContextTestLoseAfterSendingBeginMainFrame);
 
 }  // namespace
 }  // namespace cc