Revert of 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 47 matching lines @@
         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) {
     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;
   }
 
   virtual scoped_ptr<TestWebGraphicsContext3D> CreateContext3d() {
     return TestWebGraphicsContext3D::Create();
   }
 
   virtual scoped_ptr<FakeOutputSurface> CreateFakeOutputSurface(bool fallback)
@@ skipping 115 matching lines @@
   virtual void InvalidateAndSetNeedsCommit() {
     // Cause damage so we try to draw.
     layer_tree_host()->root_layer()->SetNeedsDisplay();
     layer_tree_host()->SetNeedsCommit();
   }
 
   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
+        {1,      // times_to_lose_during_commit
          0,      // times_to_lose_during_draw
          0,      // times_to_fail_recreate
          false,  // fallback_context_works
         },
-        {
-         0,      // times_to_lose_during_commit
+        {0,      // times_to_lose_during_commit
          1,      // times_to_lose_during_draw
          0,      // times_to_fail_recreate
          false,  // fallback_context_works
         },
-        {
-         1,      // times_to_lose_during_commit
+        {1,      // times_to_lose_during_commit
          0,      // times_to_lose_during_draw
          3,      // times_to_fail_recreate
          false,  // fallback_context_works
         },
-        {
-         0,      // times_to_lose_during_commit
+        {0,      // times_to_lose_during_commit
          1,      // times_to_lose_during_draw
          3,      // times_to_fail_recreate
          false,  // fallback_context_works
         },
         // Losing the context and recreating it any number of times should
         // succeed.
-        {
-         10,     // times_to_lose_during_commit
+        {10,     // times_to_lose_during_commit
          0,      // times_to_lose_during_draw
          0,      // times_to_fail_recreate
          false,  // fallback_context_works
         },
-        {
-         0,      // times_to_lose_during_commit
+        {0,      // times_to_lose_during_commit
          10,     // times_to_lose_during_draw
          0,      // times_to_fail_recreate
          false,  // fallback_context_works
         },
         // Losing the context, failing to reinitialize it, and making a fallback
         // context should work.
-        {
-         0,     // times_to_lose_during_commit
+        {0,     // times_to_lose_during_commit
          1,     // times_to_lose_during_draw
          0,     // times_to_fail_recreate
          true,  // fallback_context_works
-        },
-    };
+        }, };
 
     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;
@@ skipping 41 matching lines @@
     EXPECT_TRUE(false);
     return scoped_ptr<OutputSurface>();
   }
 
   virtual void DidInitializeOutputSurface() OVERRIDE { EXPECT_TRUE(false); }
 
   virtual void AfterTest() OVERRIDE {
   }
 };
 
-SINGLE_AND_MULTI_THREAD_TEST_F(
-    LayerTreeHostClientNotReadyDoesNotCreateOutputSurface);
+MULTI_THREAD_TEST_F(LayerTreeHostClientNotReadyDoesNotCreateOutputSurface);
 
 class LayerTreeHostContextTestLostContextSucceedsWithContent
     : public LayerTreeHostContextTestLostContextSucceeds {
  public:
   virtual void SetupTree() OVERRIDE {
     root_ = Layer::Create();
     root_->SetBounds(gfx::Size(10, 10));
     root_->SetIsDrawable(true);
 
     content_ = FakeContentLayer::Create(&client_);
@@ skipping 37 matching lines @@
     : 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) {
-    times_to_fail_create_ = times_to_fail_;
-  }
+        times_initialized_(0) {}
 
   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 593 matching lines @@
         // backtrack).
         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.
+        // http://crbug.com/287250
+        if (HasImplThread())
+          NOTREACHED();
+        break;
       default:
         NOTREACHED();
     }
   }
 
  private:
   int commits_;
   scoped_refptr<FakePaintedScrollbarLayer> scrollbar_layer_;
 };
 
@@ skipping 23 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());
-    ImplThreadTaskRunner()->PostTask(
-        FROM_HERE,
-        base::Bind(&LayerTreeHostContextTest::LoseContext,
-                   base::Unretained(this)));
+    base::SingleThreadTaskRunner* task_runner =
+        HasImplThread() ? ImplThreadTaskRunner()
+                        : base::MessageLoopProxy::current();
+    task_runner->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 34 matching lines @@
         // Expects a valid UIResourceId.
         EXPECT_NE(0, ui_resource_->id());
         PostSetNeedsCommitToMainThread();
         break;
       case 4:
         // Release resource before ending the test.
         ui_resource_.reset();
         EndTest();
         break;
       case 5:
+        // Single thread proxy issues extra commits after context lost.
+        // http://crbug.com/287250
+        if (HasImplThread())
+          NOTREACHED();
+        break;
+      case 6:
         NOTREACHED();
-        break;
     }
   }
 
   virtual void StepCompleteOnImplThread(LayerTreeHostImpl* impl) OVERRIDE {
     LayerTreeHostContextTest::CommitCompleteOnThread(impl);
     switch (time_step_) {
       case 1:
         // The resource should have been created on LTHI after the commit.
         EXPECT_NE(0u, impl->ResourceIdForUIResource(ui_resource_->id()));
         PostSetNeedsCommitToMainThread();
@@ skipping 67 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();
+        break;
+      case 8:
         NOTREACHED();
-        break;
     }
   }
 
   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_));
-        // The second resource should have been created.
-        EXPECT_NE(0u, impl->ResourceIdForUIResource(test_id1_));
+        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 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 295 matching lines @@
     EXPECT_FALSE(layer_tree_host()->output_surface_lost());
   }
 
   virtual void DidCommitAndDrawFrame() OVERRIDE { EndTest(); }
 
   virtual void AfterTest() OVERRIDE {}
 
   bool deferred_;
 };
 
-SINGLE_AND_MULTI_THREAD_TEST_F(
-    LayerTreeHostContextTestLoseAfterSendingBeginMainFrame);
+// TODO(danakj): We don't use scheduler with SingleThreadProxy yet.
+MULTI_THREAD_TEST_F(LayerTreeHostContextTestLoseAfterSendingBeginMainFrame);
 
 }  // namespace
 }  // namespace cc