Make cc output surface creation async

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"
@@ skipping 45 matching lines @@
       : 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) {
+        fallback_context_works_(false),
+        async_output_surface_creation_(false) {
     media::InitializeMediaLibraryForTesting();
   }
 
   void LoseContext() {
     // 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;
@@ skipping 69 matching lines @@
   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_;
 };
 
 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) {}
 
   virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 
+  virtual void RequestNewOutputSurface(bool fallback) OVERRIDE {
+    if (async_output_surface_creation_) {
+      MainThreadTaskRunner()->PostTask(
+          FROM_HERE,
+          base::Bind(&LayerTreeHostContextTestLostContextSucceeds::
+                         CreateAndSetOutputSurface,
+                     base::Unretained(this),
+                     fallback));
+    } else {
+      CreateAndSetOutputSurface(fallback);
+    }
+  }
+
+  void CreateAndSetOutputSurface(bool fallback) {
+    layer_tree_host()->SetOutputSurface(
+        LayerTreeHostContextTest::CreateOutputSurface(fallback));
+  }
+
   virtual void DidInitializeOutputSurface() OVERRIDE {
     if (first_initialized_)
       ++num_losses_;
     else
       first_initialized_ = true;
 
     recovered_context_ = true;
   }
 
-  virtual void AfterTest() OVERRIDE { EXPECT_EQ(7u, test_case_); }
+  virtual void AfterTest() OVERRIDE { EXPECT_EQ(11u, test_case_); }
 
   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;
@@ skipping 13 matching lines @@
 
   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
         },
         {
          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
         },
         {
          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
         },
         {
          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
+         true,   // async_output_surface_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
         },
         {
          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
+        },
+        {
+         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
+        },
+        {
+         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
         },
         // 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
+         true,  // async_output_surface_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;
     ++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;
   };
 
  protected:
   size_t test_case_;
   int num_losses_;
   int num_losses_last_test_case_;
   bool recovered_context_;
   bool first_initialized_;
 };
 
@@ skipping 1360 matching lines @@
   virtual void AfterTest() OVERRIDE {}
 
   bool deferred_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostContextTestLoseAfterSendingBeginMainFrame);
 
 }  // namespace
 }  // namespace cc