cc: remove flaky LayerTreeHostTestFinishAllRendering

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 1510 matching lines @@
   scoped_refptr<FakeContentLayer> parent_;
   scoped_refptr<FakeContentLayer> child_;
 };
 
 // Partial updates are not possible with a delegating renderer.
 SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(
     LayerTreeHostTestAtomicCommitWithPartialUpdate);
 
 class LayerTreeHostTestFinishAllRendering : public LayerTreeHostTest {
  public:
-  LayerTreeHostTestFinishAllRendering() : once_(false), draw_count_(0) {}
+  LayerTreeHostTestFinishAllRendering()
+      : once_(false),
+        has_called_finish_all_rendering_(false) {}
 
   virtual void BeginTest() OVERRIDE {
     layer_tree_host()->SetNeedsRedraw();
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void DidCommitAndDrawFrame() OVERRIDE {
-    if (once_)
-      return;
-    once_ = true;
-    layer_tree_host()->SetNeedsRedraw();
-    {
-      base::AutoLock lock(lock_);
-      draw_count_ = 0;
-    }
+    EXPECT_TRUE(once_);
     layer_tree_host()->FinishAllRendering();
-    {
-      base::AutoLock lock(lock_);
-      EXPECT_EQ(0, draw_count_);

[danakj, 2014/05/20 18:40:30]

Hm, before this test was verifying that FinishAllRendering() (when needs-redraw
is true) does not end up doing a draw.

After this change, the test doesn't really verify anything except that
DidCommitAndDrawFrame happens after DrawLayersOnThread, and that
FinishAllRendering doesn't crash.

This test was added in https://bugs.webkit.org/show_bug.cgi?id=86919 to verify
that we don't draw during FinishAllRendering to not have bad interaction with
acquire layer textures. The latter no longer exists, and I'm not sure how to
test this well without it being flaky, and the finish all rendering code path no
longer goes anywhere near drawing.

I propose we remove this test.

-    }
+    has_called_finish_all_rendering_ = true;
+
     EndTest();
   }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
-    base::AutoLock lock(lock_);
-    ++draw_count_;
+    once_ = true;
   }
 
-  virtual void AfterTest() OVERRIDE {}
+  virtual void AfterTest() OVERRIDE {
+    EXPECT_TRUE(has_called_finish_all_rendering_);
+  }
 
  private:
   bool once_;
-  base::Lock lock_;
-  int draw_count_;
+  bool has_called_finish_all_rendering_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestFinishAllRendering);
 
 class LayerTreeHostTestSurfaceNotAllocatedForLayersOutsideMemoryLimit
     : public LayerTreeHostTest {
  protected:
   virtual void SetupTree() OVERRIDE {
     root_layer_ = FakeContentLayer::Create(&client_);
     root_layer_->SetBounds(gfx::Size(100, 100));
@@ skipping 3358 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