Make SingleThreadProxy a SchedulerClient

cc/trees/layer_tree_host_unittest.cc

 // Copyright 2011 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 <algorithm>
 
 #include "base/auto_reset.h"
 #include "base/synchronization/lock.h"
@@ skipping 73 matching lines @@
     num_draws_++;
     if (!impl->active_tree()->source_frame_number())
       EndTest();
   }
 
   virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     num_commits_++;
   }
 
   virtual void AfterTest() OVERRIDE {
-    EXPECT_GE(1, num_commits_);
-    EXPECT_GE(1, num_draws_);
+    EXPECT_LE(1, num_commits_);
+    EXPECT_LE(1, num_draws_);
   }
 
  private:
   int num_commits_;
   int num_draws_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestSetNeedsCommit1);
 
 // A SetNeedsCommit should lead to 1 commit. Issuing a second commit after that
@@ skipping 581 matching lines @@
 
  private:
   scoped_refptr<Layer> root_layer_;
   scoped_refptr<Layer> parent_layer_;
   scoped_refptr<Layer> child_layer_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostTestUndrawnLayersPushContentBoundsLater);
 
-class LayerTreeHostTestAbortFrameWhenInvisible : public LayerTreeHostTest {

[enne (OOO), 2014/08/09 00:04:43]

This test is redundant with
LayerTreeHostTestBreakSwapPromiseForVisibilityAbortedCommit, which doesn't use
EndTestAfterDelay(1) and a flaky check and instead uses swap promises to verify
commits are explicitly aborted.

- public:
-  LayerTreeHostTestAbortFrameWhenInvisible() {}
-
-  virtual void BeginTest() OVERRIDE {
-    // Request a commit (from the main thread), Which will trigger the commit
-    // flow from the impl side.
-    layer_tree_host()->SetNeedsCommit();
-    // Then mark ourselves as not visible before processing any more messages
-    // on the main thread.
-    layer_tree_host()->SetVisible(false);
-    // If we make it without kicking a frame, we pass!
-    EndTestAfterDelay(1);
-  }
-
-  virtual void Layout() OVERRIDE {
-    ASSERT_FALSE(true);
-    EndTest();
-  }
-
-  virtual void AfterTest() OVERRIDE {}
-};
-
-MULTI_THREAD_TEST_F(LayerTreeHostTestAbortFrameWhenInvisible);
-
 // This test verifies that properties on the layer tree host are commited
 // to the impl side.
 class LayerTreeHostTestCommit : public LayerTreeHostTest {
  public:
   LayerTreeHostTestCommit() {}
 
   virtual void BeginTest() OVERRIDE {
     layer_tree_host()->SetViewportSize(gfx::Size(20, 20));
     layer_tree_host()->set_background_color(SK_ColorGRAY);
 
@@ skipping 1220 matching lines @@
   virtual void AfterTest() OVERRIDE {
     EXPECT_EQ(1, num_commits_deferred_);
     EXPECT_EQ(2, num_complete_commits_);
   }
 
  private:
   int num_commits_deferred_;
   int num_complete_commits_;
 };
 
-MULTI_THREAD_TEST_F(LayerTreeHostTestDeferCommits);
+SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestDeferCommits);
 
 class LayerTreeHostWithProxy : public LayerTreeHost {
  public:
   LayerTreeHostWithProxy(FakeLayerTreeHostClient* client,
                          const LayerTreeSettings& settings,
                          scoped_ptr<FakeProxy> proxy)
       : LayerTreeHost(client, NULL, settings) {
     proxy->SetLayerTreeHost(this);
     InitializeForTesting(proxy.PassAs<Proxy>());
   }
@@ skipping 52 matching lines @@
 
     EXPECT_EQ(10u, host.MaxPartialTextureUpdates());
   }
 }
 
 TEST(LayerTreeHostTest, PartialUpdatesWithGLRenderer) {
   FakeLayerTreeHostClient client(FakeLayerTreeHostClient::DIRECT_3D);
 
   LayerTreeSettings settings;
   settings.max_partial_texture_updates = 4;
+  settings.single_thread_proxy_scheduler = false;
 
   scoped_ptr<SharedBitmapManager> shared_bitmap_manager(
       new TestSharedBitmapManager());
   scoped_ptr<LayerTreeHost> host =
       LayerTreeHost::CreateSingleThreaded(&client,
                                           &client,
                                           shared_bitmap_manager.get(),
                                           settings,
                                           base::MessageLoopProxy::current());
   host->Composite(base::TimeTicks::Now());
 
   EXPECT_EQ(4u, host->settings().max_partial_texture_updates);
 }
 
 TEST(LayerTreeHostTest, PartialUpdatesWithSoftwareRenderer) {
   FakeLayerTreeHostClient client(FakeLayerTreeHostClient::DIRECT_SOFTWARE);
 
   LayerTreeSettings settings;
   settings.max_partial_texture_updates = 4;
+  settings.single_thread_proxy_scheduler = false;
 
   scoped_ptr<SharedBitmapManager> shared_bitmap_manager(
       new TestSharedBitmapManager());
   scoped_ptr<LayerTreeHost> host =
       LayerTreeHost::CreateSingleThreaded(&client,
                                           &client,
                                           shared_bitmap_manager.get(),
                                           settings,
                                           base::MessageLoopProxy::current());
   host->Composite(base::TimeTicks::Now());
 
   EXPECT_EQ(4u, host->settings().max_partial_texture_updates);
 }
 
 TEST(LayerTreeHostTest, PartialUpdatesWithDelegatingRendererAndGLContent) {
   FakeLayerTreeHostClient client(FakeLayerTreeHostClient::DELEGATED_3D);
 
   LayerTreeSettings settings;
   settings.max_partial_texture_updates = 4;
+  settings.single_thread_proxy_scheduler = false;
 
   scoped_ptr<SharedBitmapManager> shared_bitmap_manager(
       new TestSharedBitmapManager());
   scoped_ptr<LayerTreeHost> host =
       LayerTreeHost::CreateSingleThreaded(&client,
                                           &client,
                                           shared_bitmap_manager.get(),
                                           settings,
                                           base::MessageLoopProxy::current());
   host->Composite(base::TimeTicks::Now());
 
   EXPECT_EQ(0u, host->MaxPartialTextureUpdates());
 }
 
 TEST(LayerTreeHostTest,
      PartialUpdatesWithDelegatingRendererAndSoftwareContent) {
   FakeLayerTreeHostClient client(FakeLayerTreeHostClient::DELEGATED_SOFTWARE);
 
   LayerTreeSettings settings;
   settings.max_partial_texture_updates = 4;
+  settings.single_thread_proxy_scheduler = false;
 
   scoped_ptr<SharedBitmapManager> shared_bitmap_manager(
       new TestSharedBitmapManager());
   scoped_ptr<LayerTreeHost> host =
       LayerTreeHost::CreateSingleThreaded(&client,
                                           &client,
                                           shared_bitmap_manager.get(),
                                           settings,
                                           base::MessageLoopProxy::current());
   host->Composite(base::TimeTicks::Now());
@@ skipping 2422 matching lines @@
   }
 
   int commit_count_;
   int commit_complete_count_;
   TestSwapPromiseResult swap_promise_result_[3];
 };
 
 // TODO(miletus): Flaky test: crbug.com/393995
 // MULTI_THREAD_TEST_F(LayerTreeHostTestBreakSwapPromise);
 
-class LayerTreeHostTestBreakSwapPromiseForAbortedCommit
+class LayerTreeHostTestBreakSwapPromiseForVisibilityAbortedCommit
     : public LayerTreeHostTest {
  protected:
-  LayerTreeHostTestBreakSwapPromiseForAbortedCommit() : commit_count_(0) {}
+  LayerTreeHostTestBreakSwapPromiseForVisibilityAbortedCommit()
+      : commit_count_(0) {}
 
   virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 
   virtual void WillBeginMainFrame() OVERRIDE {
     layer_tree_host()->SetDeferCommits(true);
     layer_tree_host()->SetNeedsCommit();
   }
 
   virtual void DidDeferCommit() OVERRIDE {
     layer_tree_host()->SetVisible(false);
@@ skipping 18 matching lines @@
       EXPECT_TRUE(swap_promise_result_.did_not_swap_called);
       EXPECT_EQ(SwapPromise::COMMIT_FAILS, swap_promise_result_.reason);
       EXPECT_TRUE(swap_promise_result_.dtor_called);
     }
   }
 
   int commit_count_;
   TestSwapPromiseResult swap_promise_result_;
 };
 
-MULTI_THREAD_TEST_F(LayerTreeHostTestBreakSwapPromiseForAbortedCommit);
+SINGLE_AND_MULTI_THREAD_TEST_F(
+    LayerTreeHostTestBreakSwapPromiseForVisibilityAbortedCommit);
+
+class LayerTreeHostTestBreakSwapPromiseForContextAbortedCommit
+    : public LayerTreeHostTest {
+ protected:
+  LayerTreeHostTestBreakSwapPromiseForContextAbortedCommit()
+      : commit_count_(0) {}
+
+  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+
+  virtual void WillBeginMainFrame() OVERRIDE {
+    layer_tree_host()->SetDeferCommits(true);
+    layer_tree_host()->SetNeedsCommit();
+  }
+
+  virtual void DidDeferCommit() OVERRIDE {
+    layer_tree_host()->DidLoseOutputSurface();
+    layer_tree_host()->SetDeferCommits(false);
+
+    scoped_ptr<SwapPromise> swap_promise(
+        new TestSwapPromise(&swap_promise_result_));
+    layer_tree_host()->QueueSwapPromise(swap_promise.Pass());
+  }
+
+  virtual void DidCommit() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+
+  virtual void BeginMainFrameAbortedOnThread(LayerTreeHostImpl* host_impl,
+                                             bool did_handle) OVERRIDE {
+    EndTest();
+  }
+
+  virtual void AfterTest() OVERRIDE {
+    {
+      base::AutoLock lock(swap_promise_result_.lock);
+      EXPECT_FALSE(swap_promise_result_.did_swap_called);
+      EXPECT_TRUE(swap_promise_result_.did_not_swap_called);
+      EXPECT_EQ(SwapPromise::COMMIT_FAILS, swap_promise_result_.reason);
+      EXPECT_TRUE(swap_promise_result_.dtor_called);
+    }
+  }
+
+  int commit_count_;
+  TestSwapPromiseResult swap_promise_result_;
+};
+
+SINGLE_AND_MULTI_THREAD_TEST_F(
+    LayerTreeHostTestBreakSwapPromiseForContextAbortedCommit);
 
 class SimpleSwapPromiseMonitor : public SwapPromiseMonitor {
  public:
   SimpleSwapPromiseMonitor(LayerTreeHost* layer_tree_host,
                            LayerTreeHostImpl* layer_tree_host_impl,
                            int* set_needs_commit_count,
                            int* set_needs_redraw_count)
       : SwapPromiseMonitor(layer_tree_host, layer_tree_host_impl),
         set_needs_commit_count_(set_needs_commit_count),
         set_needs_redraw_count_(set_needs_redraw_count) {}
@@ skipping 59 matching lines @@
       EXPECT_EQ(3, set_needs_commit_count);
       EXPECT_EQ(0, set_needs_redraw_count);
     }
 
     EndTest();
   }
 
   virtual void AfterTest() OVERRIDE {}
 };
 
-MULTI_THREAD_TEST_F(LayerTreeHostTestSimpleSwapPromiseMonitor);
+SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestSimpleSwapPromiseMonitor);
 
 class LayerTreeHostTestHighResRequiredAfterEvictingUIResources
     : public LayerTreeHostTest {
  protected:
   virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
     settings->impl_side_painting = true;
   }
 
   virtual void SetupTree() OVERRIDE {
     LayerTreeHostTest::SetupTree();
@@ skipping 292 matching lines @@
   const gfx::Size bounds_;
   FakeContentLayerClient client_;
   scoped_refptr<ContentLayerWithUpdateTracking> content_layer_;
   scoped_refptr<FakePictureLayer> picture_layer_;
   Layer* child_layer_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestContinuousPainting);
 
 }  // namespace cc