cc: Release main thread earlier

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 797 matching lines @@
   scoped_refptr<ContentLayer> root_layer_;
   scoped_refptr<FakeContentLayer> parent_layer_;
   scoped_refptr<FakeContentLayer> child_layer_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestUndrawnLayersDamageLater);
 
 // If the layerTreeHost says it can't draw, Then we should not try to draw.
 class LayerTreeHostTestCanDrawBlocksDrawing : public LayerTreeHostTest {
  public:
-  LayerTreeHostTestCanDrawBlocksDrawing() : num_commits_(0), done_(false) {}
+  LayerTreeHostTestCanDrawBlocksDrawing() : done_(false) {}
 
   virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     if (done_)
       return;
     // Only the initial draw should bring us here.
     EXPECT_TRUE(impl->CanDraw());
     EXPECT_EQ(0, impl->active_tree()->source_frame_number());
   }
 
   virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     if (done_)
       return;
-    if (num_commits_ >= 1) {
+    if (LastCommittedSourceFrameNumber(impl) >= 1) {
       // After the first commit, we should not be able to draw.
       EXPECT_FALSE(impl->CanDraw());
     }
   }
 
   virtual void DidCommit() OVERRIDE {
-    num_commits_++;
-    if (num_commits_ == 1) {
-      // Make the viewport empty so the host says it can't draw.
-      layer_tree_host()->SetViewportSize(gfx::Size(0, 0));
-    } else if (num_commits_ == 2) {
-      char pixels[4];
-      layer_tree_host()->CompositeAndReadback(&pixels, gfx::Rect(0, 0, 1, 1));
-    } else if (num_commits_ == 3) {
-      // Let it draw so we go idle and end the test.
-      layer_tree_host()->SetViewportSize(gfx::Size(1, 1));
-      done_ = true;
-      EndTest();
+    switch (layer_tree_host()->source_frame_number()) {
+      case 1:
+        // Make the viewport empty so the host says it can't draw.
+        layer_tree_host()->SetViewportSize(gfx::Size(0, 0));
+        break;
+      case 2: {
+        char pixels[4];
+        layer_tree_host()->CompositeAndReadback(&pixels, gfx::Rect(0, 0, 1, 1));
+        break;
+      }
+      case 3:
+        // Let it draw so we go idle and end the test.
+        layer_tree_host()->SetViewportSize(gfx::Size(1, 1));
+        done_ = true;
+        EndTest();
+        break;
     }
   }
 
   virtual void AfterTest() OVERRIDE {}
 
  private:
-  int num_commits_;
   bool done_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestCanDrawBlocksDrawing);
 
 // beginLayerWrite should prevent draws from executing until a commit occurs
 class LayerTreeHostTestWriteLayersRedraw : public LayerTreeHostTest {
  public:
   LayerTreeHostTestWriteLayersRedraw() : num_commits_(0), num_draws_(0) {}
 
@@ skipping 2203 matching lines @@
   bool did_initialize_gl_;
   bool did_release_gl_;
   int last_source_frame_number_drawn_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestDeferredInitialize);
 
 // Test for UI Resource management.
 class LayerTreeHostTestUIResource : public LayerTreeHostTest {
  public:
-  LayerTreeHostTestUIResource() : num_ui_resources_(0), num_commits_(0) {}
+  LayerTreeHostTestUIResource() : num_ui_resources_(0) {}
 
   virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
     settings->texture_id_allocation_chunk_size = 1;
   }
 
   virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 
   virtual void DidCommit() OVERRIDE {
-    int frame = num_commits_;
+    int frame = layer_tree_host()->source_frame_number();
     switch (frame) {
       case 1:
         CreateResource();
         CreateResource();
         PostSetNeedsCommitToMainThread();
         break;
       case 2:
         // Usually ScopedUIResource are deleted from the manager in their
         // destructor.  Here we just want to test that a direct call to
         // DeleteUIResource works.
@@ skipping 13 matching lines @@
       case 5:
         ClearResources();
         EndTest();
         break;
     }
   }
 
   void PerformTest(LayerTreeHostImpl* impl) {
     TestWebGraphicsContext3D* context = TestContext();
 
-    int frame = num_commits_;
+    int frame = impl->active_tree()->source_frame_number();
     switch (frame) {
-      case 1:
+      case 0:
         ASSERT_EQ(0u, context->NumTextures());
         break;
-      case 2:
+      case 1:
         // Created two textures.
         ASSERT_EQ(2u, context->NumTextures());
         break;
-      case 3:
+      case 2:
         // One texture left after one deletion.
         ASSERT_EQ(1u, context->NumTextures());
         break;
-      case 4:
+      case 3:
         // Resource manager state should not change when delete is called on an
         // invalid id.
         ASSERT_EQ(1u, context->NumTextures());
         break;
-      case 5:
+      case 4:
         // Creation after deletion: two more creates should total up to
         // three textures.
         ASSERT_EQ(3u, context->NumTextures());
         break;
     }
   }
 
   virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
-    ++num_commits_;
     if (!layer_tree_host()->settings().impl_side_painting)
       PerformTest(impl);
   }
 
   virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     if (layer_tree_host()->settings().impl_side_painting)
       PerformTest(impl);
   }
 
   virtual void AfterTest() OVERRIDE {}
 
  private:
   // Must clear all resources before exiting.
   void ClearResources() {
     for (int i = 0; i < num_ui_resources_; i++)
       ui_resources_[i].reset();
   }
 
   void CreateResource() {
     ui_resources_[num_ui_resources_++] =
         FakeScopedUIResource::Create(layer_tree_host());
   }
 
   scoped_ptr<FakeScopedUIResource> ui_resources_[5];
   int num_ui_resources_;
-  int num_commits_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestUIResource);
 
 class PushPropertiesCountingLayerImpl : public LayerImpl {
  public:
   static scoped_ptr<PushPropertiesCountingLayerImpl> Create(
       LayerTreeImpl* tree_impl, int id) {
     return make_scoped_ptr(new PushPropertiesCountingLayerImpl(tree_impl, id));
   }
@@ skipping 1294 matching lines @@
 MULTI_THREAD_TEST_F(LayerTreeHostTestMaxTransferBufferUsageBytes);
 
 // Test ensuring that memory limits are sent to the prioritized resource
 // manager.
 class LayerTreeHostTestMemoryLimits : public LayerTreeHostTest {
  public:
   LayerTreeHostTestMemoryLimits() : num_commits_(0) {}
 
   virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 
+  virtual void WillCommit() OVERRIDE {
+    // Some commits are aborted, so increment number of attempted commits here.
+    num_commits_++;

[brianderson, 2014/01/23 22:48:49]

To handle the aborted commits, could we keep two counters instead? One for the
main commit count and another for the impl commit count. That way, it's easier
to reason about the thread safety.

[enne (OOO), 2014/01/23 23:01:36]

WillCommit is called when the main thread is blocked, so I'm not sure what the
thread safety issue is here.

+  }
+
   virtual void DidCommit() OVERRIDE {
-    int frame = num_commits_;
-    switch (frame) {
-      case 0:
+    switch (num_commits_) {
+      case 1:
         // Verify default values.
         EXPECT_EQ(PrioritizedResourceManager::DefaultMemoryAllocationLimit(),
                   layer_tree_host()
                       ->contents_texture_manager()
                       ->MaxMemoryLimitBytes());
         EXPECT_EQ(PriorityCalculator::AllowEverythingCutoff(),
                   layer_tree_host()
                       ->contents_texture_manager()
                       ->ExternalPriorityCutoff());
         PostSetNeedsCommitToMainThread();
         break;
-      case 1:
+      case 2:
         // The values should remain the same until the commit after the policy
         // is changed.
         EXPECT_EQ(PrioritizedResourceManager::DefaultMemoryAllocationLimit(),
                   layer_tree_host()
                       ->contents_texture_manager()
                       ->MaxMemoryLimitBytes());
         EXPECT_EQ(PriorityCalculator::AllowEverythingCutoff(),
                   layer_tree_host()
                       ->contents_texture_manager()
                       ->ExternalPriorityCutoff());
         break;
-      case 2:
+      case 3:
         // Verify values were correctly passed.
         EXPECT_EQ(16u * 1024u * 1024u,
                   layer_tree_host()
                       ->contents_texture_manager()
                       ->MaxMemoryLimitBytes());
         EXPECT_EQ(PriorityCalculator::AllowVisibleAndNearbyCutoff(),
                   layer_tree_host()
                       ->contents_texture_manager()
                       ->ExternalPriorityCutoff());
         EndTest();
         break;
-      case 3:
+      case 4:
         // Make sure no extra commits happen.
         NOTREACHED();
         break;
     }
-
-    ++num_commits_;
   }
 
   virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
-    int frame = num_commits_;
-    switch (frame) {
-      case 0:
+    switch (num_commits_) {
+      case 1:
         break;
-      case 1:
+      case 2:
         // This will trigger a commit because the priority cutoff has changed.
         impl->SetMemoryPolicy(ManagedMemoryPolicy(
             16u * 1024u * 1024u,
             gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE,
             1000));
         break;
-      case 2:
+      case 3:
         // This will not trigger a commit because the priority cutoff has not
         // changed, and there is already enough memory for all allocations.
         impl->SetMemoryPolicy(ManagedMemoryPolicy(
             32u * 1024u * 1024u,
             gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE,
             1000));
         break;
-      case 3:
+      case 4:
         NOTREACHED();
         break;
     }
   }
 
   virtual void AfterTest() OVERRIDE {}
 
  private:
   int num_commits_;
 };
@@ skipping 375 matching lines @@
 
     EndTest();
   }
 
   virtual void AfterTest() OVERRIDE {}
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestSimpleSwapPromiseMonitor);
 
 }  // namespace cc