cc: Use BeginFrameArgs

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 47 matching lines @@
 using testing::AnyNumber;
 using testing::AtLeast;
 using testing::Mock;
 
 namespace cc {
 namespace {
 
 class LayerTreeHostTest : public LayerTreeTest {
 };
 
-// Two setNeedsCommits in a row should lead to at least 1 commit and at least 1
-// draw with frame 0.
+// Two setNeedsCommits in a row should lead to 1 commit and 1 draw.
 class LayerTreeHostTestSetNeedsCommit1 : public LayerTreeHostTest {
  public:
   LayerTreeHostTestSetNeedsCommit1() : num_commits_(0), num_draws_(0) {}
 
   virtual void BeginTest() OVERRIDE {
     PostSetNeedsCommitToMainThread();
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     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_EQ(num_commits_, 1);
+    EXPECT_EQ(num_draws_, 1);
   }
 
  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 514 matching lines @@
 
 // A compositeAndReadback while invisible should force a normal commit without
 // assertion.
 class LayerTreeHostTestCompositeAndReadbackWhileInvisible
     : public LayerTreeHostTest {
  public:
   LayerTreeHostTestCompositeAndReadbackWhileInvisible() : num_commits_(0) {}
 
   virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommit() OVERRIDE {
     num_commits_++;
     if (num_commits_ == 1) {
       layer_tree_host()->SetVisible(false);
       layer_tree_host()->SetNeedsCommit();
       layer_tree_host()->SetNeedsCommit();
       char pixels[4];
       layer_tree_host()->CompositeAndReadback(&pixels, gfx::Rect(0, 0, 1, 1));
     } else {
       EndTest();
     }
@@ skipping 58 matching lines @@
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestCommit);
 
 // This test verifies that LayerTreeHostImpl's current frame time gets
 // updated in consecutive frames when it doesn't draw due to tree
 // activation failure.
 class LayerTreeHostTestFrameTimeUpdatesAfterActivationFails
     : public LayerTreeHostTest {
  public:
-  LayerTreeHostTestFrameTimeUpdatesAfterActivationFails() : frame_(0) {}
+  LayerTreeHostTestFrameTimeUpdatesAfterActivationFails()
+      : frame_count_with_pending_tree_(0) {}
 
   virtual void BeginTest() OVERRIDE {
     layer_tree_host()->SetViewportSize(gfx::Size(20, 20));
     layer_tree_host()->set_background_color(SK_ColorGRAY);
 
     PostSetNeedsCommitToMainThread();
   }
 
+  virtual void WillBeginFrameOnThread(LayerTreeHostImpl* host_impl,
+                                      const BeginFrameArgs& args) OVERRIDE {
+    if (host_impl->pending_tree())
+      frame_count_with_pending_tree_++;
+  }
+
   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
-    if (frame_ >= 1) {
-      EXPECT_NE(first_frame_time_, impl->CurrentFrameTimeTicks());
+    if (frame_count_with_pending_tree_ > 1) {
+      EXPECT_NE(first_frame_time_.ToInternalValue(),
+                impl->CurrentFrameTimeTicks().ToInternalValue());
       EndTest();
       return;
     }
 
     EXPECT_FALSE(impl->settings().impl_side_painting);
     EndTest();
   }
 
   virtual bool CanActivatePendingTree(LayerTreeHostImpl* impl) OVERRIDE {
-    if (frame_ >= 1)
-      return true;
-
-    return false;
+    return frame_count_with_pending_tree_ > 1;
   }
 
-  virtual bool CanActivatePendingTreeIfNeeded(LayerTreeHostImpl* impl)
-      OVERRIDE {
-    frame_++;
-    if (frame_ == 1) {
-      first_frame_time_ = impl->CurrentFrameTimeTicks();
-
-      // Since base::TimeTicks::Now() uses a low-resolution clock on
-      // Windows, we need to make sure that the clock has incremented past
-      // first_frame_time_.
-      while (first_frame_time_ == base::TimeTicks::Now()) {}
-
-      return false;
-    }
-
-    return true;
+  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+    if (impl->settings().impl_side_painting)
+      EXPECT_NE(frame_count_with_pending_tree_, 1);
   }
 
   virtual void AfterTest() OVERRIDE {}
 
  private:
-  int frame_;
+  int frame_count_with_pending_tree_;
   base::TimeTicks first_frame_time_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostTestFrameTimeUpdatesAfterActivationFails);
 
 // This test verifies that LayerTreeHostImpl's current frame time gets
 // updated in consecutive frames when it draws in each frame.
 class LayerTreeHostTestFrameTimeUpdatesAfterDraw : public LayerTreeHostTest {
  public:
@@ skipping 61 matching lines @@
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void ApplyScrollAndScale(gfx::Vector2d scroll_delta, float scale)
       OVERRIDE {
     gfx::Vector2d offset = scroll_layer_->scroll_offset();
     scroll_layer_->SetScrollOffset(offset + scroll_delta);
     layer_tree_host()->SetPageScaleFactorAndLimits(scale, 0.5f, 2.f);
   }
 
-  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) OVERRIDE {
-    impl->ProcessScrollDeltas();
+  virtual void SwapBuffersOnThread(LayerTreeHostImpl* impl,
+                                   bool result) OVERRIDE {
     // We get one commit before the first draw, and the animation doesn't happen
     // until the second draw.
     switch (impl->active_tree()->source_frame_number()) {
       case 0:
         EXPECT_EQ(1.f, impl->active_tree()->page_scale_factor());
         // We'll start an animation when we get back to the main thread.
         break;
       case 1:
         EXPECT_EQ(1.f, impl->active_tree()->page_scale_factor());
-        PostSetNeedsRedrawToMainThread();
         break;
       case 2:
         EXPECT_EQ(1.25f, impl->active_tree()->page_scale_factor());
         EndTest();
         break;
       default:
         NOTREACHED();
     }
   }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommit() OVERRIDE {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 0.5f, 2.f);
         layer_tree_host()->StartPageScaleAnimation(
             gfx::Vector2d(), false, 1.25f, base::TimeDelta());
         break;
     }
   }
 
   virtual void AfterTest() OVERRIDE {}
@@ skipping 443 matching lines @@
     parent_->AddChild(child_);
 
     layer_tree_host()->SetRootLayer(parent_);
     LayerTreeHostTest::SetupTree();
   }
 
   virtual void BeginTest() OVERRIDE {
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommit() OVERRIDE {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         parent_->SetNeedsDisplay();
         child_->SetNeedsDisplay();
         break;
       case 2:
         // Damage part of layers.
         parent_->SetNeedsDisplayRect(gfx::RectF(0.f, 0.f, 5.f, 5.f));
         child_->SetNeedsDisplayRect(gfx::RectF(0.f, 0.f, 5.f, 5.f));
         break;
@@ skipping 110 matching lines @@
 
 class LayerTreeHostTestFinishAllRendering : public LayerTreeHostTest {
  public:
   LayerTreeHostTestFinishAllRendering() : once_(false), draw_count_(0) {}
 
   virtual void BeginTest() OVERRIDE {
     layer_tree_host()->SetNeedsRedraw();
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommit() OVERRIDE {
     if (once_)
       return;
     once_ = true;
     layer_tree_host()->SetNeedsRedraw();
     layer_tree_host()->AcquireLayerTextures();
     {
       base::AutoLock lock(lock_);
       draw_count_ = 0;
     }
     layer_tree_host()->FinishAllRendering();
@@ skipping 67 matching lines @@
     surface_layer2_->SetReplicaLayer(replica_layer2_.get());
 
     layer_tree_host()->SetRootLayer(root_layer_);
     LayerTreeHostTest::SetupTree();
   }
 
   virtual void BeginTest() OVERRIDE {
     PostSetNeedsCommitToMainThread();
   }
 
+  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+    if (host_impl->active_tree()->source_frame_number() == 0) {
+      // Reduce the memory limit to only fit the root layer and one render
+      // surface. This prevents any contents drawing into surfaces
+      // from being allocated.
+      host_impl->SetMemoryPolicy(ManagedMemoryPolicy(100 * 100 * 4 * 2));
+      host_impl->SetDiscardBackBufferWhenNotVisible(true);
+
+      // If ManageTiles ever deallocates resources before the subsequent draw,
+      // this test will need to change.
+      host_impl->ManageTiles();
+    }
+  }
+
   virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
     Renderer* renderer = host_impl->renderer();
     RenderPass::Id surface1_render_pass_id = host_impl->active_tree()
         ->root_layer()->children()[0]->render_surface()->RenderPassId();
     RenderPass::Id surface2_render_pass_id =
         host_impl->active_tree()->root_layer()->children()[0]->children()[0]
         ->render_surface()->RenderPassId();
 
     switch (host_impl->active_tree()->source_frame_number()) {
       case 0:
         EXPECT_TRUE(renderer->HaveCachedResourcesForRenderPassId(
             surface1_render_pass_id));
         EXPECT_TRUE(renderer->HaveCachedResourcesForRenderPassId(
             surface2_render_pass_id));
-
-        // Reduce the memory limit to only fit the root layer and one render
-        // surface. This prevents any contents drawing into surfaces
-        // from being allocated.
-        host_impl->SetMemoryPolicy(ManagedMemoryPolicy(100 * 100 * 4 * 2));
-        host_impl->SetDiscardBackBufferWhenNotVisible(true);
         break;
       case 1:
         EXPECT_FALSE(renderer->HaveCachedResourcesForRenderPassId(
             surface1_render_pass_id));
         EXPECT_FALSE(renderer->HaveCachedResourcesForRenderPassId(
             surface2_render_pass_id));
-
         EndTest();
         break;
     }
   }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommit() OVERRIDE {
     if (layer_tree_host()->source_frame_number() < 2)
       root_layer_->SetNeedsDisplay();
   }
 
   virtual void AfterTest() OVERRIDE {
     EXPECT_LE(2u, root_layer_->update_count());
     EXPECT_LE(2u, surface_layer1_->update_count());
     EXPECT_LE(2u, surface_layer2_->update_count());
   }
 
@@ skipping 285 matching lines @@
     content_layer_ = ContentLayer::Create(&client_);
     content_layer_->SetBounds(gfx::Size(10, 10));
     content_layer_->SetPosition(gfx::PointF(0.f, 0.f));
     content_layer_->SetAnchorPoint(gfx::PointF(0.f, 0.f));
     content_layer_->SetIsDrawable(true);
     layer_tree_host()->root_layer()->AddChild(content_layer_);
 
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
-    if (num_draw_layers_ == 2)
-      return;
-    content_layer_->SetNeedsDisplay();
-  }
+  virtual void DidCommit() OVERRIDE { content_layer_->SetNeedsDisplay(); }
 
   virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
-    if (num_draw_layers_ == 1)
-      num_commit_complete_++;
+    EXPECT_EQ(num_draw_layers_, num_commit_complete_);
+    num_commit_complete_++;
   }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     num_draw_layers_++;
     if (num_draw_layers_ == 2)
       EndTest();
   }
 
-  virtual void AfterTest() OVERRIDE {
-    // Check that we didn't commit twice between first and second draw.
-    EXPECT_EQ(1, num_commit_complete_);
-  }
+  virtual void AfterTest() OVERRIDE {}
 
  private:
   FakeContentLayerClient client_;
   scoped_refptr<Layer> content_layer_;
   int num_commit_complete_;
   int num_draw_layers_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestContinuousInvalidate);
 
@@ skipping 357 matching lines @@
     settings->using_synchronous_renderer_compositor = true;
   }
 
   virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 
   virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
     // The BeginFrame notification is turned off now but will get enabled
     // once we return. End test while it's enabled.
     ImplThreadTaskRunner()->PostTask(
         FROM_HERE,
-        base::Bind(&LayerTreeHostTestBeginFrameNotification::EndTest,
-                   base::Unretained(this)));
+        base::Bind(
+            &LayerTreeHostTestBeginFrameNotificationShutdownWhileEnabled::
+                EndTest,
+            base::Unretained(this)));
   }
 
   virtual void AfterTest() OVERRIDE {}
 };
 
 MULTI_THREAD_TEST_F(
     LayerTreeHostTestBeginFrameNotificationShutdownWhileEnabled);
 
 class LayerTreeHostTestUninvertibleTransformDoesNotBlockActivation
     : public LayerTreeHostTest {
@@ skipping 226 matching lines @@
     root->AddChild(child);
 
     layer_tree_host()->SetRootLayer(root);
     LayerTreeHostTest::SetupTree();
   }
 
   virtual void BeginTest() OVERRIDE {
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
-    WaitForCallback();
-  }
+  virtual void DidCommit() OVERRIDE { WaitForCallback(); }
 
   void WaitForCallback() {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(
             &LayerTreeHostTestAsyncReadback::NextStep,
             base::Unretained(this)));
   }
 
   void NextStep() {
@@ skipping 661 matching lines @@
         layer_tree_host()->SetNeedsRedraw();
         break;
       case 3:
         // CompositeAndReadback in Round 4, first commit.
         EXPECT_EQ(2, frame_);
         break;
       case 4:
         // Round 4 done.
         EXPECT_EQ(2, frame_);
         layer_tree_host()->SetNeedsCommit();
+        // We can't SetNeedsRedraw immediately because it will race the commit.
+        break;
+      case 5:
+        EXPECT_EQ(2, frame_);
         layer_tree_host()->SetNeedsRedraw();
         break;
     }
   }
 
   virtual void DidCompleteSwapBuffers() OVERRIDE {
     int commit = layer_tree_host()->source_frame_number();
     ++frame_;
     char pixels[4] = {0};
     switch (frame_) {
@@ skipping 302 matching lines @@
       child2_->AddChild(leaf_picture_layer_);
     if (leaf_content_layer_)
       child2_->AddChild(leaf_content_layer_);
 
     other_root_ = PushPropertiesCountingLayer::Create();
 
     // Don't set the root layer here.
     LayerTreeHostTest::SetupTree();
   }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommit() OVERRIDE {
     ++num_commits_;
 
     EXPECT_EQ(expected_push_properties_root_, root_->push_properties_count());
     EXPECT_EQ(expected_push_properties_child_, child_->push_properties_count());
     EXPECT_EQ(expected_push_properties_grandchild_,
               grandchild_->push_properties_count());
     EXPECT_EQ(expected_push_properties_child2_,
               child2_->push_properties_count());
     EXPECT_EQ(expected_push_properties_other_root_,
               other_root_->push_properties_count());
@@ skipping 173 matching lines @@
     bool has_thumb = false;
     scrollbar_layer_ =
         FakeScrollbarLayer::Create(paint_scrollbar, has_thumb, root_->id());
 
     root_->AddChild(scrollbar_layer_);
 
     layer_tree_host()->SetRootLayer(root_);
     LayerTreeHostTest::SetupTree();
   }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommit() OVERRIDE {
     switch (layer_tree_host()->source_frame_number()) {
       case 0:
         break;
       case 1: {
         // During update, the ignore_set_needs_commit_ bit is set to true to
         // avoid causing a second commit to be scheduled. If a property change
         // is made during this, however, it needs to be pushed in the upcoming
         // commit.
         scoped_ptr<base::AutoReset<bool> > ignore =
             scrollbar_layer_->IgnoreSetNeedsCommit();
@@ skipping 62 matching lines @@
   size_t expected_push_properties_root_;
   size_t expected_push_properties_child_;
   size_t expected_push_properties_grandchild1_;
   size_t expected_push_properties_grandchild2_;
   size_t expected_push_properties_grandchild3_;
 };
 
 class LayerTreeHostTestPushPropertiesAddingToTreeRequiresPush
     : public LayerTreeHostTestCasePushPropertiesThreeGrandChildren {
  protected:
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommit() OVERRIDE {
     int last_source_frame_number = layer_tree_host()->source_frame_number() - 1;
     switch (last_source_frame_number) {
       case 0:
         EXPECT_FALSE(root_->needs_push_properties());
         EXPECT_FALSE(root_->descendant_needs_push_properties());
         EXPECT_FALSE(child_->needs_push_properties());
         EXPECT_FALSE(child_->descendant_needs_push_properties());
         EXPECT_FALSE(grandchild1_->needs_push_properties());
         EXPECT_FALSE(grandchild1_->descendant_needs_push_properties());
         EXPECT_FALSE(grandchild2_->needs_push_properties());
@@ skipping 19 matching lines @@
         break;
     }
   }
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestPushPropertiesAddingToTreeRequiresPush);
 
 class LayerTreeHostTestPushPropertiesRemovingChildStopsRecursion
     : public LayerTreeHostTestCasePushPropertiesThreeGrandChildren {
  protected:
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommit() OVERRIDE {
     int last_source_frame_number = layer_tree_host()->source_frame_number() - 1;
     switch (last_source_frame_number) {
       case 0:
         layer_tree_host()->SetRootLayer(root_);
         break;
       case 1:
         EXPECT_FALSE(root_->needs_push_properties());
         EXPECT_FALSE(root_->descendant_needs_push_properties());
         EXPECT_FALSE(child_->needs_push_properties());
         EXPECT_FALSE(child_->descendant_needs_push_properties());
@@ skipping 62 matching lines @@
         break;
     }
   }
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestPushPropertiesRemovingChildStopsRecursion);
 
 class LayerTreeHostTestPushPropertiesRemovingChildStopsRecursionWithPersistence
     : public LayerTreeHostTestCasePushPropertiesThreeGrandChildren {
  protected:
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommit() OVERRIDE {
     int last_source_frame_number = layer_tree_host()->source_frame_number() - 1;
     switch (last_source_frame_number) {
       case 0:
         layer_tree_host()->SetRootLayer(root_);
         grandchild1_->set_persist_needs_push_properties(true);
         grandchild2_->set_persist_needs_push_properties(true);
         break;
       case 1:
         EXPECT_FALSE(root_->needs_push_properties());
         EXPECT_TRUE(root_->descendant_needs_push_properties());
@@ skipping 27 matching lines @@
     }
   }
 };
 
 MULTI_THREAD_TEST_F(
     LayerTreeHostTestPushPropertiesRemovingChildStopsRecursionWithPersistence);
 
 class LayerTreeHostTestPushPropertiesSetPropertiesWhileOutsideTree
     : public LayerTreeHostTestCasePushPropertiesThreeGrandChildren {
  protected:
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommit() OVERRIDE {
     int last_source_frame_number = layer_tree_host()->source_frame_number() - 1;
     switch (last_source_frame_number) {
       case 0:
         layer_tree_host()->SetRootLayer(root_);
         break;
       case 1:
         EXPECT_FALSE(root_->needs_push_properties());
         EXPECT_FALSE(root_->descendant_needs_push_properties());
         EXPECT_FALSE(child_->needs_push_properties());
         EXPECT_FALSE(child_->descendant_needs_push_properties());
@@ skipping 47 matching lines @@
     }
   }
 };
 
 MULTI_THREAD_TEST_F(
     LayerTreeHostTestPushPropertiesSetPropertiesWhileOutsideTree);
 
 class LayerTreeHostTestPushPropertiesSetPropertyInParentThenChild
     : public LayerTreeHostTestCasePushPropertiesThreeGrandChildren {
  protected:
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommit() OVERRIDE {
     int last_source_frame_number = layer_tree_host()->source_frame_number() - 1;
     switch (last_source_frame_number) {
       case 0:
         layer_tree_host()->SetRootLayer(root_);
         break;
       case 1:
         EXPECT_FALSE(root_->needs_push_properties());
         EXPECT_FALSE(root_->descendant_needs_push_properties());
         EXPECT_FALSE(child_->needs_push_properties());
         EXPECT_FALSE(child_->descendant_needs_push_properties());
@@ skipping 43 matching lines @@
     }
   }
 };
 
 MULTI_THREAD_TEST_F(
     LayerTreeHostTestPushPropertiesSetPropertyInParentThenChild);
 
 class LayerTreeHostTestPushPropertiesSetPropertyInChildThenParent
     : public LayerTreeHostTestCasePushPropertiesThreeGrandChildren {
  protected:
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommit() OVERRIDE {
     int last_source_frame_number = layer_tree_host()->source_frame_number() - 1;
     switch (last_source_frame_number) {
       case 0:
         layer_tree_host()->SetRootLayer(root_);
         break;
       case 1:
         EXPECT_FALSE(root_->needs_push_properties());
         EXPECT_FALSE(root_->descendant_needs_push_properties());
         EXPECT_FALSE(child_->needs_push_properties());
         EXPECT_FALSE(child_->descendant_needs_push_properties());
@@ skipping 364 matching lines @@
   int num_will_begin_frames_;
   int num_impl_commits_;
 };
 
 // Commits can only be aborted when using the thread proxy.
 MULTI_THREAD_TEST_F(LayerTreeHostTestAbortEvictedTextures);
 
 }  // namespace
 
 }  // namespace cc