Add a flag to allow renderer to use software compositor when GL compositor doesn't work.

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/heads_up_display_layer.h"
 #include "cc/layers/io_surface_layer.h"
@@ skipping 44 matching lines @@
         times_to_lose_during_draw_(0),
         times_to_fail_recreate_(0),
         times_to_fail_reinitialize_(0),
         times_to_lose_on_recreate_(0),
         times_to_fail_create_offscreen_(0),
         times_to_fail_recreate_offscreen_(0),
         times_to_expect_create_failed_(0),
         times_create_failed_(0),
         times_offscreen_created_(0),
         committed_at_least_once_(false),
-        context_should_support_io_surface_(false) {
+        context_should_support_io_surface_(false),
+        fallback_context_works_(false) {
     media::InitializeMediaLibraryForTesting();
   }
 
   void LoseContext() {
     context3d_->loseContextCHROMIUM(GL_GUILTY_CONTEXT_RESET_ARB,
                                     GL_INNOCENT_CONTEXT_RESET_ARB);
     context3d_ = NULL;
   }
 
   virtual scoped_ptr<TestWebGraphicsContext3D> CreateContext3d() {
     return TestWebGraphicsContext3D::Create();
   }
 
-  virtual scoped_ptr<OutputSurface> CreateOutputSurface() OVERRIDE {
+  virtual scoped_ptr<OutputSurface> CreateOutputSurface(bool fallback)
+      OVERRIDE {
     if (times_to_fail_create_) {
       --times_to_fail_create_;
       ExpectCreateToFail();
       return scoped_ptr<OutputSurface>();
     }
 
     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);
     }
 
-    if (times_to_fail_initialize_) {
+    if (times_to_fail_initialize_ && !(fallback && fallback_context_works_)) {
       --times_to_fail_initialize_;
       // Make the context get lost during reinitialization.
       // The number of times MakeCurrent succeeds is not important, and
       // can be changed if needed to make this pass with future changes.
       context3d_->set_times_make_current_succeeds(2);
       ExpectCreateToFail();
     } else if (times_to_lose_on_create_) {
       --times_to_lose_on_create_;
       LoseContext();
       ExpectCreateToFail();
@@ skipping 119 matching lines @@
   int times_to_fail_recreate_;
   int times_to_fail_reinitialize_;
   int times_to_lose_on_recreate_;
   int times_to_fail_create_offscreen_;
   int times_to_fail_recreate_offscreen_;
   int times_to_expect_create_failed_;
   int times_create_failed_;
   int times_offscreen_created_;
   bool committed_at_least_once_;
   bool context_should_support_io_surface_;
+  bool fallback_context_works_;
 
   scoped_refptr<FakeContextProvider> offscreen_contexts_main_thread_;
   scoped_refptr<FakeContextProvider> offscreen_contexts_compositor_thread_;
 };
 
 class LayerTreeHostContextTestLostContextSucceeds
     : public LayerTreeHostContextTest {
  public:
   LayerTreeHostContextTestLostContextSucceeds()
       : LayerTreeHostContextTest(),
@@ skipping 11 matching lines @@
 
     if (first_initialized_)
       ++num_losses_;
     else
       first_initialized_ = true;
 
     recovered_context_ = true;
   }
 
   virtual void AfterTest() OVERRIDE {
-    EXPECT_EQ(10u, test_case_);
-    EXPECT_EQ(8 + 10 + 10, num_losses_);
+    EXPECT_EQ(11u, test_case_);
+    EXPECT_EQ(8 + 10 + 10 + 1, num_losses_);

[danakj, 2013/07/30 01:04:07]

Heh, I should have commented this variable the last time I figured out what all
the numbers were. Oh well..

   }
 
   virtual void DidCommitAndDrawFrame() OVERRIDE {
     // If the last frame had a context loss, then we'll commit again to
     // recover.
     if (!recovered_context_)
       return;
     if (times_to_lose_during_commit_)
       return;
     if (times_to_lose_during_draw_)
       return;
 
     recovered_context_ = false;
     if (NextTestCase())
       InvalidateAndSetNeedsCommit();
     else
       EndTest();
   }
 
   virtual void InvalidateAndSetNeedsCommit() {
     // Cause damage so we try to draw.
     layer_tree_host()->root_layer()->SetNeedsDisplay();
   }
 
   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
-        3,  // times_to_fail_reinitialize
-        0,  // times_to_fail_recreate
-        0,  // times_to_lose_on_recreate
-        0,  // times_to_fail_recreate_offscreen
-      },
-      { 0,  // times_to_lose_during_commit
-        1,  // times_to_lose_during_draw
-        3,  // times_to_fail_reinitialize
-        0,  // times_to_fail_recreate
-        0,  // times_to_lose_on_recreate
-        0,  // times_to_fail_recreate_offscreen
-      },
-      { 1,  // times_to_lose_during_commit
-        0,  // times_to_lose_during_draw
-        0,  // times_to_fail_reinitialize
-        3,  // times_to_fail_recreate
-        0,  // times_to_lose_on_recreate
-        0,  // times_to_fail_recreate_offscreen
-      },
-      { 0,  // times_to_lose_during_commit
-        1,  // times_to_lose_during_draw
-        0,  // times_to_fail_reinitialize
-        3,  // times_to_fail_recreate
-        0,  // times_to_lose_on_recreate
-        0,  // times_to_fail_recreate_offscreen
-      },
-      { 1,  // times_to_lose_during_commit
-        0,  // times_to_lose_during_draw
-        0,  // times_to_fail_reinitialize
-        0,  // times_to_fail_recreate
-        3,  // times_to_lose_on_recreate
-        0,  // times_to_fail_recreate_offscreen
-      },
-      { 0,  // times_to_lose_during_commit
-        1,  // times_to_lose_during_draw
-        0,  // times_to_fail_reinitialize
-        0,  // times_to_fail_recreate
-        3,  // times_to_lose_on_recreate
-        0,  // times_to_fail_recreate_offscreen
-      },
-      { 1,  // times_to_lose_during_commit
-        0,  // times_to_lose_during_draw
-        0,  // times_to_fail_reinitialize
-        0,  // times_to_fail_recreate
-        0,  // times_to_lose_on_recreate
-        3,  // times_to_fail_recreate_offscreen
-      },
-      { 0,  // times_to_lose_during_commit
-        1,  // times_to_lose_during_draw
-        0,  // times_to_fail_reinitialize
-        0,  // times_to_fail_recreate
-        0,  // times_to_lose_on_recreate
-        3,  // times_to_fail_recreate_offscreen
-      },
-      // Losing the context and recreating it any number of times should
+      { 1,      // times_to_lose_during_commit
+        0,      // times_to_lose_during_draw
+        3,      // times_to_fail_reinitialize
+        0,      // times_to_fail_recreate
+        0,      // times_to_lose_on_recreate
+        0,      // times_to_fail_recreate_offscreen
+        false,  // fallback_context_works
+    },
+      { 0,      // times_to_lose_during_commit
+        1,      // times_to_lose_during_draw
+        3,      // times_to_fail_reinitialize
+        0,      // times_to_fail_recreate
+        0,      // times_to_lose_on_recreate
+        0,      // times_to_fail_recreate_offscreen
+        false,  // fallback_context_works
+    },
+      { 1,      // times_to_lose_during_commit
+        0,      // times_to_lose_during_draw
+        0,      // times_to_fail_reinitialize
+        3,      // times_to_fail_recreate
+        0,      // times_to_lose_on_recreate
+        0,      // times_to_fail_recreate_offscreen
+        false,  // fallback_context_works
+    },
+      { 0,      // times_to_lose_during_commit
+        1,      // times_to_lose_during_draw
+        0,      // times_to_fail_reinitialize
+        3,      // times_to_fail_recreate
+        0,      // times_to_lose_on_recreate
+        0,      // times_to_fail_recreate_offscreen
+        false,  // fallback_context_works
+    },
+      { 1,      // times_to_lose_during_commit
+        0,      // times_to_lose_during_draw
+        0,      // times_to_fail_reinitialize
+        0,      // times_to_fail_recreate
+        3,      // times_to_lose_on_recreate
+        0,      // times_to_fail_recreate_offscreen
+        false,  // fallback_context_works
+    },
+      { 0,      // times_to_lose_during_commit
+        1,      // times_to_lose_during_draw
+        0,      // times_to_fail_reinitialize
+        0,      // times_to_fail_recreate
+        3,      // times_to_lose_on_recreate
+        0,      // times_to_fail_recreate_offscreen
+        false,  // fallback_context_works
+    },
+      { 1,      // times_to_lose_during_commit
+        0,      // times_to_lose_during_draw
+        0,      // times_to_fail_reinitialize
+        0,      // times_to_fail_recreate
+        0,      // times_to_lose_on_recreate
+        3,      // times_to_fail_recreate_offscreen
+        false,  // fallback_context_works
+    },
+      { 0,      // times_to_lose_during_commit
+        1,      // times_to_lose_during_draw
+        0,      // times_to_fail_reinitialize
+        0,      // times_to_fail_recreate
+        0,      // times_to_lose_on_recreate
+        3,      // times_to_fail_recreate_offscreen
+        false,  // fallback_context_works
+    },
+             // 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_reinitialize
-        0,  // times_to_fail_recreate
-        0,  // times_to_lose_on_recreate
-        0,  // times_to_fail_recreate_offscreen
-      },
-      { 0,  // times_to_lose_during_commit
-        10,  // times_to_lose_during_draw
-        0,  // times_to_fail_reinitialize
-        0,  // times_to_fail_recreate
-        0,  // times_to_lose_on_recreate
-        0,  // times_to_fail_recreate_offscreen
-      },
+        0,   // times_to_lose_during_draw
+        0,   // times_to_fail_reinitialize
+        0,   // times_to_fail_recreate
+        0,   // times_to_lose_on_recreate
+        0,   // times_to_fail_recreate_offscreen
+        false,  // fallback_context_works
+    },
+      { 0,      // times_to_lose_during_commit
+        10,     // times_to_lose_during_draw
+        0,      // times_to_fail_reinitialize
+        0,      // times_to_fail_recreate
+        0,      // times_to_lose_on_recreate
+        0,      // times_to_fail_recreate_offscreen
+        false,  // fallback_context_works
+    },
+      // 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
+        10,     // times_to_fail_reinitialize
+        0,      // times_to_fail_recreate
+        0,      // times_to_lose_on_recreate
+        0,      // times_to_fail_recreate_offscreen
+        true,   // fallback_context_works
+    },
     };
 
     if (test_case_ >= arraysize(kTests))
       return false;
 
     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_reinitialize_ = kTests[test_case_].times_to_fail_reinitialize;
     times_to_fail_recreate_ = kTests[test_case_].times_to_fail_recreate;
     times_to_lose_on_recreate_ = kTests[test_case_].times_to_lose_on_recreate;
     times_to_fail_recreate_offscreen_ =
         kTests[test_case_].times_to_fail_recreate_offscreen;
+    fallback_context_works_ = kTests[test_case_].fallback_context_works;
     ++test_case_;
     return true;
   }
 
   struct TestCase {
     int times_to_lose_during_commit;
     int times_to_lose_during_draw;
     int times_to_fail_reinitialize;
     int times_to_fail_recreate;
     int times_to_lose_on_recreate;
     int times_to_fail_recreate_offscreen;
+    bool fallback_context_works;
   };
 
  protected:
   size_t test_case_;
   int num_losses_;
   bool recovered_context_;
   bool first_initialized_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostContextTestLostContextSucceeds);
@@ skipping 56 matching lines @@
     }
   }
 
   virtual void AfterTest() OVERRIDE {
     LayerTreeHostContextTestLostContextSucceeds::AfterTest();
     if (use_surface_) {
       // 1 create to start with +
       // 6 from test cases that fail on initializing the renderer (after the
       // offscreen context is created) +
       // 6 from test cases that lose the offscreen context directly +
+      // 4 from test cases that create a fallback +
       // All the test cases that recreate both contexts only once
       // per time it is lost.
-      EXPECT_EQ(6 + 6 + 1 + num_losses_, times_offscreen_created_);
+      EXPECT_EQ(6 + 6 + 1 + 4 + num_losses_, times_offscreen_created_);
     } else {
       EXPECT_EQ(0, times_offscreen_created_);
     }
   }
 
  protected:
   bool use_surface_;
   FakeContentLayerClient client_;
   scoped_refptr<Layer> root_;
   scoped_refptr<ContentLayer> content_;
@@ skipping 1087 matching lines @@
 
 // Not reusing LayerTreeTest because it expects creating LTH to always succeed.
 class LayerTreeHostTestCannotCreateIfCannotCreateOutputSurface
     : public testing::Test,
       public FakeLayerTreeHostClient {
  public:
   LayerTreeHostTestCannotCreateIfCannotCreateOutputSurface()
       : FakeLayerTreeHostClient(FakeLayerTreeHostClient::DIRECT_3D) {}
 
   // FakeLayerTreeHostClient implementation.
-  virtual scoped_ptr<OutputSurface> CreateOutputSurface() OVERRIDE {
+  virtual scoped_ptr<OutputSurface> CreateOutputSurface(bool fallback)
+      OVERRIDE {
     return scoped_ptr<OutputSurface>();
   }
 
   void RunTest(bool threaded,
                bool delegating_renderer,
                bool impl_side_painting) {
     scoped_ptr<base::Thread> impl_thread;
     if (threaded) {
       impl_thread.reset(new base::Thread("LayerTreeTest"));
       ASSERT_TRUE(impl_thread->Start());
       ASSERT_TRUE(impl_thread->message_loop_proxy().get());
     }
 
     LayerTreeSettings settings;
     settings.impl_side_painting = impl_side_painting;
     scoped_ptr<LayerTreeHost> layer_tree_host = LayerTreeHost::Create(
         this,
         settings,
         impl_thread ? impl_thread->message_loop_proxy() : NULL);
     EXPECT_FALSE(layer_tree_host);
   }
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostTestCannotCreateIfCannotCreateOutputSurface);
 
 }  // namespace
 }  // namespace cc