Make SingleThreadProxy a SchedulerClient

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 49 matching lines @@
         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),
         fallback_context_works_(false) {
     media::InitializeMediaLibraryForTesting();
   }
 
   void LoseContext() {
-    context3d_->loseContextCHROMIUM(GL_GUILTY_CONTEXT_RESET_ARB,
-                                    GL_INNOCENT_CONTEXT_RESET_ARB);
+    // For sanity-checking tests, they should only call this when the
+    // context is not lost.
+    CHECK(context3d_);
+
+    // Set the context3d_ member to null *before* calling lose context,
+    // as the single-threaded proxy may synchronously recreate the
+    // output surface, setting context3d_ back to not-NULL.
+    TestWebGraphicsContext3D* temp_context3d = context3d_;
     context3d_ = NULL;
+    temp_context3d->loseContextCHROMIUM(GL_GUILTY_CONTEXT_RESET_ARB,
+                                        GL_INNOCENT_CONTEXT_RESET_ARB);
   }
 
   virtual scoped_ptr<TestWebGraphicsContext3D> CreateContext3d() {
     return TestWebGraphicsContext3D::Create();
   }
 
   virtual scoped_ptr<FakeOutputSurface> CreateFakeOutputSurface(bool fallback)
       OVERRIDE {
     if (times_to_fail_create_) {
       --times_to_fail_create_;
@@ skipping 407 matching lines @@
   // 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,
                                                    bool expect_to_give_up)
       : times_to_fail_(times_to_fail),
         expect_fallback_attempt_(expect_fallback_attempt),
         expect_to_give_up_(expect_to_give_up),
         did_attempt_fallback_(false),
-        times_initialized_(0) {}
+        times_initialized_(0) {
+    times_to_fail_create_ = times_to_fail_;
+  }
 
   virtual void BeginTest() OVERRIDE {
-    times_to_fail_create_ = times_to_fail_;
     PostSetNeedsCommitToMainThread();
   }
 
   virtual scoped_ptr<FakeOutputSurface> CreateFakeOutputSurface(bool fallback)
       OVERRIDE {
     scoped_ptr<FakeOutputSurface> surface =
         LayerTreeHostContextTest::CreateFakeOutputSurface(fallback);
 
     if (surface)
       EXPECT_EQ(times_to_fail_, times_create_failed_);
@@ skipping 712 matching lines @@
                                    bool result) OVERRIDE {
     // We should only swap for the replacement commit.
     EXPECT_EQ(host_impl->active_tree()->source_frame_number(), 1);
     EndTest();
   }
 
  private:
   int times_output_surface_created_;
 };
 
-SINGLE_AND_MULTI_THREAD_TEST_F(
+// This test is only valid for the multi-threaded proxy.  The single-threaded
+// case synchronously creates the first output surface (tested just below)
+// and so there is no way that a readback could happen during this time.
+MULTI_THREAD_TEST_F(
     LayerTreeHostContextTestCompositeAndReadbackBeforeOutputSurfaceInit);
 
+class LayerTreeHostContextTestSingleThreadSynchronouslyCreatesOutputSurface
+    : public LayerTreeHostContextTest {
+ public:
+  virtual void WillBeginTest() OVERRIDE {
+    // Output surface should be synchronously created, to avoid any potential
+    // readback issues before the first output surface is created.
+    ASSERT_TRUE(layer_tree_host()->output_surface_lost());
+    LayerTreeHostContextTest::WillBeginTest();
+    ASSERT_FALSE(layer_tree_host()->output_surface_lost());
+  }
+
+  virtual void BeginTest() OVERRIDE { EndTest(); }
+  virtual void AfterTest() OVERRIDE {}
+};
+SINGLE_THREAD_TEST_F(
+    LayerTreeHostContextTestSingleThreadSynchronouslyCreatesOutputSurface);
+
 // This test verifies that losing an output surface during a
 // simultaneous readback and forced redraw works and does not deadlock.
 class LayerTreeHostContextTestLoseOutputSurfaceDuringReadbackAndForcedDraw
     : public LayerTreeHostContextTest {
  protected:
   static const int kFirstOutputSurfaceInitSourceFrameNumber = 0;
   static const int kReadbackSourceFrameNumber = 1;
   static const int kReadbackReplacementSourceFrameNumber = 2;
   static const int kSecondOutputSurfaceInitSourceFrameNumber = 3;
 
@@ skipping 226 matching lines @@
         EXPECT_EQ(1, scrollbar_layer_->update_count());
         LoseContext();
         break;
       case 2:
         // Second update, after the lost context, we should still upload 2
         // resources even if the contents haven't changed.
         EXPECT_EQ(2, scrollbar_layer_->update_count());
         EndTest();
         break;
       case 3:
         // Single thread proxy issues extra commits after context lost.

[danakj, 2014/02/19 20:42:39]

How come these other cases aren't fixed by this CL too? Or can we remove all
these similar if(HasImplThread()) ?

[enne (OOO), 2014/02/20 00:35:44]

Good catch.  Done.

         // http://crbug.com/287250
         if (HasImplThread())
           NOTREACHED();
         break;
       default:
         NOTREACHED();
     }
   }
 
  private:
@@ skipping 27 matching lines @@
   void PostStepCompleteToMainThread() {
     proxy()->MainThreadTaskRunner()->PostTask(
         FROM_HERE,
         base::Bind(&UIResourceLostTest::StepCompleteOnMainThreadInternal,
                    base::Unretained(this),
                    time_step_));
   }
 
   void PostLoseContextToImplThread() {
     EXPECT_TRUE(layer_tree_host()->proxy()->IsMainThread());
-    base::SingleThreadTaskRunner* task_runner =
-        HasImplThread() ? ImplThreadTaskRunner()
-                        : base::MessageLoopProxy::current();
-    task_runner->PostTask(FROM_HERE,
-                          base::Bind(&LayerTreeHostContextTest::LoseContext,
-                                     base::Unretained(this)));
+    ImplThreadTaskRunner()->PostTask(
+        FROM_HERE,
+        base::Bind(&LayerTreeHostContextTest::LoseContext,
+                   base::Unretained(this)));
   }
 
  protected:
   int time_step_;
   scoped_ptr<FakeScopedUIResource> ui_resource_;
 
  private:
   void StepCompleteOnMainThreadInternal(int step) {
     EXPECT_TRUE(layer_tree_host()->proxy()->IsMainThread());
     StepCompleteOnMainThread(step);
@@ skipping 128 matching lines @@
         layer_tree_host()->DeleteUIResource(test_id0_);
         // Delete the resouce and then lose the context.
         PostLoseContextToImplThread();
         break;
       case 5:
         // Release resource before ending the test.
         ui_resource_.reset();
         EndTest();
         break;
       case 6:
-        // Single thread proxy issues extra commits after context lost.
-        // http://crbug.com/287250
-        if (HasImplThread())
-          NOTREACHED();
+        NOTREACHED();
         break;
-      case 8:
-        NOTREACHED();
     }
   }
 
   virtual void StepCompleteOnImplThread(LayerTreeHostImpl* impl) OVERRIDE {
     LayerTreeHostContextTest::CommitCompleteOnThread(impl);
     switch (time_step_) {
       case 1:
         // Sequence 1 (continued):
         // The first context lost happens before the resources were created,
         // and because it resulted in no resources being destroyed, it does not
         // trigger resource re-creation.
         EXPECT_EQ(1, ui_resource_->resource_create_count);
         EXPECT_EQ(0, ui_resource_->lost_resource_count);
         // Resource Id on the impl-side has been created.
         PostSetNeedsCommitToMainThread();
         break;
       case 3:
         // Sequence 2 (continued):
         // The previous resource should have been deleted.
         EXPECT_EQ(0u, impl->ResourceIdForUIResource(test_id0_));
-        if (HasImplThread()) {
-          // The second resource should have been created.
-          EXPECT_NE(0u, impl->ResourceIdForUIResource(test_id1_));
-        } else {
-          // The extra commit that happens at context lost in the single thread
-          // proxy changes the timing so that the resource has been destroyed.
-          // http://crbug.com/287250
-          EXPECT_EQ(0u, impl->ResourceIdForUIResource(test_id1_));
-        }
+        // The second resource should have been created.
+        EXPECT_NE(0u, impl->ResourceIdForUIResource(test_id1_));
         // The second resource called the resource callback once and since the
         // context is lost, a "resource lost" callback was also issued.
         EXPECT_EQ(2, ui_resource_->resource_create_count);
         EXPECT_EQ(1, ui_resource_->lost_resource_count);
         break;
       case 5:
         // Sequence 3 (continued):
         // Expect the resource callback to have been called once.
         EXPECT_EQ(1, ui_resource_->resource_create_count);
         // No "resource lost" callbacks.
@@ skipping 245 matching lines @@
 
  protected:
   FakeContentLayerClient client_;
   scoped_refptr<FakeContentLayer> layer_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostContextTestSurfaceCreateCallback);
 
 }  // namespace
 }  // namespace cc