cc: Release main thread earlier

cc/trees/layer_tree_host_unittest_delegated.cc

 // Copyright 2013 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/bind.h"
 #include "base/location.h"
@@ skipping 1838 matching lines @@
         EXPECT_EQ(1u, delegated_impl->Resources().count(555));
     }
   }
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDelegatedTestCommitWithoutTake);
 
 class DelegatedFrameIsActivatedDuringCommit
     : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
  protected:
-  DelegatedFrameIsActivatedDuringCommit()
-      : wait_thread_("WAIT"),
-        wait_event_(false, false),
-        returned_resource_count_(0) {
-    wait_thread_.Start();
-  }
+  DelegatedFrameIsActivatedDuringCommit() : returned_resource_count_(0) {}
 
   virtual void BeginTest() OVERRIDE {
     activate_count_ = 0;
 
     scoped_ptr<DelegatedFrameData> frame =
         CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
     AddTextureQuad(frame.get(), 999);
     AddTransferableResource(frame.get(), 999);
     SetFrameData(frame.Pass());
 
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void WillActivateTreeOnThread(LayerTreeHostImpl* impl) OVERRIDE {
-    // Slow down activation so the main thread DidCommit() will run if
-    // not blocked.
-    wait_thread_.message_loop()->PostDelayedTask(
-        FROM_HERE,
-        base::Bind(&base::WaitableEvent::Signal,
-                   base::Unretained(&wait_event_)),
-        base::TimeDelta::FromMilliseconds(10));
-    wait_event_.Wait();
-
-    base::AutoLock lock(activate_lock_);
     ++activate_count_;
   }
 
-  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) OVERRIDE {
-    // The main thread is awake now, and will run DidCommit() immediately.
-    // Run DidActivate() afterwards by posting it now.
-    proxy()->MainThreadTaskRunner()->PostTask(
-        FROM_HERE,
-        base::Bind(&DelegatedFrameIsActivatedDuringCommit::DidActivate,
-                   base::Unretained(this)));
-  }
-
-  void DidActivate() {
-    base::AutoLock lock(activate_lock_);
-    switch (activate_count_) {
+  virtual void DidCommit() OVERRIDE {
+    switch (layer_tree_host()->source_frame_number()) {
       case 1: {
         // The first frame has been activated. Set a new frame, and
         // expect the next commit to finish *after* it is activated.
         scoped_ptr<DelegatedFrameData> frame =
             CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 555);
         AddTransferableResource(frame.get(), 555);
         SetFrameData(frame.Pass());
-        // So this commit number should complete after the second activate.
-        EXPECT_EQ(1, layer_tree_host()->source_frame_number());
         break;
       }
       case 2:
         // The second frame has been activated. Remove the layer from
         // the tree to cause another commit/activation. The commit should
         // finish *after* the layer is removed from the active tree.
         delegated_->RemoveFromParent();
-        // So this commit number should complete after the third activate.
-        EXPECT_EQ(2, layer_tree_host()->source_frame_number());
+        break;
+      case 3:
+        scoped_ptr<DelegatedFrameData> frame =
+            CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
+        SetFrameData(frame.Pass());

[brianderson, 2014/01/15 00:59:38]

What is this extra case needed for?

[enne (OOO), 2014/01/15 01:21:49]

This is needed to kick off the UnusedResourcesAreAvailable call below by
clearing the frame data.

         break;
     }
   }
 
-  virtual void DidCommit() OVERRIDE {

[enne (OOO), 2014/01/15 00:36:04]

Main thread DidCommit is now racy with respect to compositor thread activation. 
All these tests are now updated to just make sure that activation has taken
place during the commit, which I think is what they were trying to do.

-    switch (layer_tree_host()->source_frame_number()) {
+  virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+    switch (host_impl->active_tree()->source_frame_number()) {
       case 2: {
         // The activate for the 2nd frame should have happened before now.
-        base::AutoLock lock(activate_lock_);
         EXPECT_EQ(2, activate_count_);
         break;
       }
       case 3: {
         // The activate to remove the layer should have happened before now.
-        base::AutoLock lock(activate_lock_);
         EXPECT_EQ(3, activate_count_);
-
-        scoped_ptr<DelegatedFrameData> frame =
-            CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
-        SetFrameData(frame.Pass());
         break;
       }
     }
   }
 
   virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
                                    bool result) OVERRIDE {
     ReturnUnusedResourcesFromParent(host_impl);
   }
 
   virtual void UnusedResourcesAreAvailable() OVERRIDE {
     LayerTreeHostDelegatedTestCaseSingleDelegatedLayer::
         UnusedResourcesAreAvailable();
     ReturnedResourceArray resources;
     resource_collection_->TakeUnusedResourcesForChildCompositor(&resources);
     EXPECT_TRUE(TestAndResetAvailable());
     returned_resource_count_ += resources.size();
     if (returned_resource_count_ == 2)
       EndTest();
   }
 
-  base::Thread wait_thread_;
-  base::WaitableEvent wait_event_;
-  base::Lock activate_lock_;
   int activate_count_;
   size_t returned_resource_count_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     DelegatedFrameIsActivatedDuringCommit);
 
 class LayerTreeHostDelegatedTestTwoImplLayers
     : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
  public:
@@ skipping 382 matching lines @@
   }
 
   scoped_refptr<DelegatedRendererLayer> delegated_thief_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostDelegatedTestRemoveAndChangeResources);
 
 }  // namespace
 }  // namespace cc