[cc] Update UIResource test threading

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/debug/test_context_provider.h"
 #include "cc/debug/test_web_graphics_context_3d.h"
 #include "cc/layers/content_layer.h"
@@ skipping 1619 matching lines @@
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostTestCannotCreateIfCannotCreateOutputSurface);
 
 class UIResourceLostTest : public LayerTreeHostContextTest {
  public:
   UIResourceLostTest() : time_step_(0) {}
   virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
   virtual void AfterTest() OVERRIDE {}
 
+  // This is called on the main thread after each commit and
+  // DidActivateTreeOnThread, with the value of time_step_ at the time
+  // of the call to DidActivateTreeOnThread. Similar tests will do
+  // work on the main thread in DidCommit but that is unsuitable because
+  // the main thread work for these tests must happen after
+  // DidActivateTreeOnThread, which happens after DidCommit with impl-side
+  // painting.
+  virtual void StepCompleteOnMainThread(int time_step) = 0;
+
+  // Called after DidActivateTreeOnThread. If this is done during the commit,
+  // the the call to StepCompleteOnMainThread will not occur until after
+  // the commit completes, because the main thread is blocked.
+  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)));
+  }
+
  protected:
   int time_step_;
   scoped_ptr<FakeScopedUIResource> ui_resource_;
+
+ private:
+  void StepCompleteOnMainThreadInternal(int step) {
+    EXPECT_TRUE(layer_tree_host()->proxy()->IsMainThread());
+    StepCompleteOnMainThread(step);
+  }
 };
 
 // Losing context after an UI resource has been created.
 class UIResourceLostAfterCommit : public UIResourceLostTest {
  public:
-  virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
-    LayerTreeHostContextTest::CommitCompleteOnThread(impl);
-    switch (time_step_) {
+  virtual void StepCompleteOnMainThread(int step) OVERRIDE {
+    EXPECT_TRUE(layer_tree_host()->proxy()->IsMainThread());
+    switch (step) {
       case 0:
         ui_resource_ = FakeScopedUIResource::Create(layer_tree_host());
         // 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:
+        // Make sure no extra commits happened.
+        NOTREACHED();
+    }
+  }
+
+  virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+    LayerTreeHostContextTest::CommitCompleteOnThread(impl);
+    switch (time_step_) {
       case 1:
         // The resource should have been created on LTHI after the commit.
         if (!layer_tree_host()->settings().impl_side_painting)
           EXPECT_NE(0u, impl->ResourceIdForUIResource(ui_resource_->id()));
         PostSetNeedsCommitToMainThread();
         break;
       case 2:
         LoseContext();
         break;
       case 3:
         // The resources should have been recreated. The bitmap callback should
         // have been called once with the resource_lost flag set to true.
         EXPECT_EQ(1, ui_resource_->lost_resource_count);
         // Resource Id on the impl-side have been recreated as well. Note
         // that the same UIResourceId persists after the context lost.
         if (!layer_tree_host()->settings().impl_side_painting)
           EXPECT_NE(0u, impl->ResourceIdForUIResource(ui_resource_->id()));
         PostSetNeedsCommitToMainThread();
         break;
-      case 4:
-        // Release resource before ending test.
-        ui_resource_.reset();
-        EndTest();
-        break;
     }
   }
 
   virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     LayerTreeHostContextTest::DidActivateTreeOnThread(impl);
     switch (time_step_) {
       case 1:
         if (layer_tree_host()->settings().impl_side_painting)
           EXPECT_NE(0u, impl->ResourceIdForUIResource(ui_resource_->id()));
         break;
       case 3:
         if (layer_tree_host()->settings().impl_side_painting)
           EXPECT_NE(0u, impl->ResourceIdForUIResource(ui_resource_->id()));
         break;
     }
+
+    PostStepCompleteToMainThread();
     ++time_step_;
   }
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(UIResourceLostAfterCommit);
 
 // Losing context before UI resource requests can be commited.  Three sequences
 // of creation/deletion are considered:
 // 1. Create one resource -> Context Lost => Expect the resource to have been
 // created.
 // 2. Delete an exisiting resource (test_id0_) -> create a second resource
 // (test_id1_) -> Context Lost => Expect the test_id0_ to be removed and
 // test_id1_ to have been created.
 // 3. Create one resource -> Delete that same resource -> Context Lost => Expect
 // the resource to not exist in the manager.
 class UIResourceLostBeforeCommit : public UIResourceLostTest {
  public:
   UIResourceLostBeforeCommit()
       : test_id0_(0),
         test_id1_(0) {}
 
-  virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
-    LayerTreeHostContextTest::CommitCompleteOnThread(impl);
-    switch (time_step_) {
+  virtual void StepCompleteOnMainThread(int step) OVERRIDE {
+    switch (step) {
       case 0:
-        // Sequence 1:
         ui_resource_ = FakeScopedUIResource::Create(layer_tree_host());
-        LoseContext();
-        // Resource Id on the impl-side should no longer be valid after
-        // context is lost.
-        EXPECT_EQ(0u, impl->ResourceIdForUIResource(ui_resource_->id()));
-        break;
-      case 1:
-        // The resources should have been recreated.
-        EXPECT_EQ(2, ui_resource_->resource_create_count);
-        // "resource lost" callback was called once for the resource in the
-        // resource map.
-        EXPECT_EQ(1, ui_resource_->lost_resource_count);
-        // Resource Id on the impl-side have been recreated as well. Note
-        // that the same UIResourceId persists after the context lost.
-        if (!layer_tree_host()->settings().impl_side_painting)
-          EXPECT_NE(0u, impl->ResourceIdForUIResource(ui_resource_->id()));
-        PostSetNeedsCommitToMainThread();
+        // Lose the context on the impl thread before the commit.
+        PostLoseContextToImplThread();
         break;
       case 2:
         // Sequence 2:
         // Currently one resource has been created.
         test_id0_ = ui_resource_->id();
         // Delete this resource.
         ui_resource_.reset();
         // Create another resource.
         ui_resource_ = FakeScopedUIResource::Create(layer_tree_host());
         test_id1_ = ui_resource_->id();
         // Sanity check that two resource creations return different ids.
         EXPECT_NE(test_id0_, test_id1_);
-        // Lose the context before commit.
-        LoseContext();
+        // Lose the context on the impl thread before the commit.
+        PostLoseContextToImplThread();
         break;
       case 3:
-        if (!layer_tree_host()->settings().impl_side_painting) {
-          // 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_));
-        }
-
-        // 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);
         // Clear the manager of resources.
         ui_resource_.reset();
         PostSetNeedsCommitToMainThread();
         break;
       case 4:
         // Sequence 3:
         ui_resource_ = FakeScopedUIResource::Create(layer_tree_host());
         test_id0_ = ui_resource_->id();
         // Sanity check the UIResourceId should not be 0.
         EXPECT_NE(0, test_id0_);
         // Usually ScopedUIResource are deleted from the manager in their
         // destructor (so usually ui_resource_.reset()).  But here we need
         // ui_resource_ for the next step, so call DeleteUIResource directly.
         layer_tree_host()->DeleteUIResource(test_id0_);
-        LoseContext();
+        // 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:
+        // TODO(ccameron): There is a bug in the single thread proxy where if
+        // the GL context is lost outside of the commit flow, then two (or more)
+        // commits follow instead of just one. The first commit will recreate
+        // the context, and the second serves no clear purpose. When that is
+        // fixed then this NOTREACHED can apply unconditionally.
+        if (HasImplThread())
+          NOTREACHED();
+        break;
+      case 8:
+        NOTREACHED();
+    }
+  }
+
+  virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+    LayerTreeHostContextTest::CommitCompleteOnThread(impl);
+    switch (time_step_) {
+      case 1:
+        // Sequence 1 (continued):
+        // The resources should have been recreated.
+        EXPECT_EQ(1, ui_resource_->resource_create_count);
+        // The "resource lost" callback wasn't called for the resource because
+        // the context was lost before the queue was processed.
+        EXPECT_EQ(0, ui_resource_->lost_resource_count);
+        // Resource Id on the impl-side have been recreated as well. Note
+        // that the same UIResourceId persists after the context lost.
+        if (!layer_tree_host()->settings().impl_side_painting)
+          EXPECT_NE(0u, impl->ResourceIdForUIResource(ui_resource_->id()));
+        PostSetNeedsCommitToMainThread();
+        break;
+      case 3:
+        // Sequence 2 (continued):
+        if (!layer_tree_host()->settings().impl_side_painting) {
+          // 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_));
+        }
+        // The "resource lost" callback wasn't called for the resource because
+        // the context was lost before the queue was processed.
+        EXPECT_EQ(1, ui_resource_->resource_create_count);
+        EXPECT_EQ(0, 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.
         EXPECT_EQ(0, ui_resource_->lost_resource_count);
         if (!layer_tree_host()->settings().impl_side_painting) {
           // The UI resource id should not be valid
           EXPECT_EQ(0u, impl->ResourceIdForUIResource(test_id0_));
         }
-        PostSetNeedsCommitToMainThread();
-        break;
-      case 6:
-        ui_resource_.reset();
-        EndTest();
         break;
     }
   }
 
   virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     LayerTreeHostContextTest::DidActivateTreeOnThread(impl);
     switch (time_step_) {
       case 1:
         if (layer_tree_host()->settings().impl_side_painting)
           EXPECT_NE(0u, impl->ResourceIdForUIResource(ui_resource_->id()));
         break;
       case 3:
         if (layer_tree_host()->settings().impl_side_painting) {
           EXPECT_EQ(0u, impl->ResourceIdForUIResource(test_id0_));
           EXPECT_NE(0u, impl->ResourceIdForUIResource(test_id1_));
         }
         break;
       case 5:
         if (layer_tree_host()->settings().impl_side_painting)
           EXPECT_EQ(0u, impl->ResourceIdForUIResource(test_id0_));
         break;
     }
+
+    PostStepCompleteToMainThread();
     ++time_step_;
   }
 
  private:
   UIResourceId test_id0_;
   UIResourceId test_id1_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(UIResourceLostBeforeCommit);
 
 // Losing UI resource before the pending trees is activated but after the
 // commit.  Impl-side-painting only.
 class UIResourceLostBeforeActivateTree : public UIResourceLostTest {
-  virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
-    LayerTreeHostContextTest::CommitCompleteOnThread(impl);
-    switch (time_step_) {
+  virtual void StepCompleteOnMainThread(int step) OVERRIDE {
+    EXPECT_TRUE(layer_tree_host()->proxy()->IsMainThread());
+    switch (step) {
       case 0:
         ui_resource_ = FakeScopedUIResource::Create(layer_tree_host());
         PostSetNeedsCommitToMainThread();
         break;
-      case 2:
-        PostSetNeedsCommitToMainThread();
-        break;
       case 3:
         test_id_ = ui_resource_->id();
         ui_resource_.reset();
         PostSetNeedsCommitToMainThread();
         break;
+      case 5:
+        // Release resource before ending the test.
+        ui_resource_.reset();
+        EndTest();
+        break;
+      case 6:
+        // Make sure no extra commits happened.
+        NOTREACHED();
+    }
+  }
+
+  virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+    LayerTreeHostContextTest::CommitCompleteOnThread(impl);
+    switch (time_step_) {
+      case 2:
+        PostSetNeedsCommitToMainThread();
+        break;
       case 4:
         PostSetNeedsCommitToMainThread();
         break;
-      case 5:
-        EndTest();
-        break;
     }
   }
 
   virtual void WillActivateTreeOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     switch (time_step_) {
-      case 0:
-        break;
       case 1:
         // The resource creation callback has been called.
         EXPECT_EQ(1, ui_resource_->resource_create_count);
         // The resource is not yet lost (sanity check).
         EXPECT_EQ(0, ui_resource_->lost_resource_count);
         // The resource should not have been created yet on the impl-side.
         EXPECT_EQ(0u, impl->ResourceIdForUIResource(ui_resource_->id()));
         LoseContext();
         break;
       case 3:
@@ skipping 12 matching lines @@
       case 2:
         // The "lost resource" callback should have been called once.
         EXPECT_EQ(1, ui_resource_->lost_resource_count);
         break;
       case 4:
         // The resource is deleted and should not be in the manager.  Use
         // test_id_ since ui_resource_ has been deleted.
         EXPECT_EQ(0u, impl->ResourceIdForUIResource(test_id_));
         break;
     }
+
+    PostStepCompleteToMainThread();
     ++time_step_;
   }
 
  private:
   UIResourceId test_id_;
 };
 
 TEST_F(UIResourceLostBeforeActivateTree,
        RunMultiThread_DirectRenderer_ImplSidePaint) {
   RunTest(true, false, true);
 }
 
 TEST_F(UIResourceLostBeforeActivateTree,
        RunMultiThread_DelegatingRenderer_ImplSidePaint) {
   RunTest(true, true, true);
 }
 
 }  // namespace
 }  // namespace cc