cc: Single-threaded impl-side painting for unit tests

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 511 matching lines @@
   virtual void AfterTest() OVERRIDE { EXPECT_EQ(5, num_draws_); }
 
  private:
   int num_draws_;
   const gfx::Size bounds_;
   const gfx::Rect invalid_rect_;
   FakeContentLayerClient client_;
   scoped_refptr<ContentLayer> root_layer_;
 };
 
-SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestSetNextCommitForcesRedraw);
+// This test does not make sense in the single-threaded impl-side painting

[enne (OOO), 2014/08/27 23:53:38]

These two tests are the only ones that called
BlockNotifyReadyToActivateForTesting and failed.  This is clearly not supported
in the SingleThreadProxy world that always calls NotifyReadyToActivate during
commit.  Unfortunately, there are other tests that call this, but they don't
fail.  

Maybe I should make BlockNotifyReadyToActivateForTesting explode if it's single
threaded and impl-side painting and then just make some
SINGLE_AND_MULTI_THREAD_BLOCKNOTIFY_TEST_F macro that runs everything but that
configuration?

[danakj, 2014/09/03 17:01:31]

I like the sound of that idea.

[enne (OOO), 2014/09/03 19:41:28]

Done.

+// configuration, as activation cannot fail.
+MULTI_THREAD_TEST_F(LayerTreeHostTestSetNextCommitForcesRedraw);
+SINGLE_THREAD_NOIMPL_TEST_F(LayerTreeHostTestSetNextCommitForcesRedraw);
 
 // Tests that if a layer is not drawn because of some reason in the parent then
 // its damage is preserved until the next time it is drawn.
 class LayerTreeHostTestUndrawnLayersDamageLater : public LayerTreeHostTest {
  public:
   LayerTreeHostTestUndrawnLayersDamageLater()
       : root_layer_(ContentLayer::Create(&client_)) {}
 
   virtual void SetupTree() OVERRIDE {
     root_layer_->SetIsDrawable(true);
@@ skipping 227 matching lines @@
       EXPECT_NE(frame_count_with_pending_tree_, 1);
   }
 
   virtual void AfterTest() OVERRIDE {}
 
  private:
   int frame_count_with_pending_tree_;
   base::TimeTicks first_frame_time_;
 };
 
-SINGLE_AND_MULTI_THREAD_TEST_F(
+// This test does not make sense in the single-threaded impl-side painting
+// configuration, as activation cannot fail.
+MULTI_THREAD_TEST_F(LayerTreeHostTestFrameTimeUpdatesAfterActivationFails);
+SINGLE_THREAD_NOIMPL_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:
   LayerTreeHostTestFrameTimeUpdatesAfterDraw() : frame_(0) {}
 
   virtual void BeginTest() OVERRIDE {
     layer_tree_host()->SetViewportSize(gfx::Size(20, 20));
@@ skipping 1421 matching lines @@
         EXPECT_FALSE(layer_tree_host()->root_layer()->can_use_lcd_text());
         EndTest();
         break;
     }
   }
 
  private:
   NotificationClient client_;
 };
 
-SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestLCDNotification);
+SINGLE_THREAD_NOIMPL_TEST_F(LayerTreeHostTestLCDNotification);

[danakj, 2014/09/03 17:01:32]

Why this? What happened to MULTI?

[enne (OOO), 2014/09/03 19:41:28]

Fixed.

 
 // Verify that the BeginFrame notification is used to initiate rendering.
 class LayerTreeHostTestBeginFrameNotification : public LayerTreeHostTest {
  public:
   virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
     settings->begin_frame_scheduling_enabled = true;
   }
 
   virtual void BeginTest() OVERRIDE {
     // This will trigger a SetNeedsBeginFrame which will trigger a
@@ skipping 163 matching lines @@
 
     virtual bool FillsBoundsCompletely() const OVERRIDE { return false; }
 
    private:
     Layer* layer_;
   };
 
   LayerTreeHostTestChangeLayerPropertiesInPaintContents() : num_commits_(0) {}
 
   virtual void SetupTree() OVERRIDE {
     scoped_refptr<ContentLayer> root_layer = ContentLayer::Create(&client_);

[danakj, 2014/09/03 17:01:31]

can you make this a PictureLayer and run this with implside instead?

[enne (OOO), 2014/09/03 19:41:28]

Added PictureLayer when impl-side painting.  Left existing code since
ContentLayer is still shipping.

     root_layer->SetIsDrawable(true);
     root_layer->SetBounds(gfx::Size(1, 1));
 
     layer_tree_host()->SetRootLayer(root_layer);
     client_.set_layer(root_layer.get());
 
     LayerTreeHostTest::SetupTree();
   }
 
   virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
   virtual void AfterTest() OVERRIDE {}
 
   virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {

[danakj, 2014/09/03 17:01:32]

This should be DidActivateOnThread since it's using the active_tree()

[enne (OOO), 2014/09/03 19:41:28]

Done.

     num_commits_++;
     if (num_commits_ == 1) {
       LayerImpl* root_layer = host_impl->active_tree()->root_layer();
       EXPECT_SIZE_EQ(gfx::Size(1, 1), root_layer->bounds());
     } else {
       LayerImpl* root_layer = host_impl->active_tree()->root_layer();
       EXPECT_SIZE_EQ(gfx::Size(2, 2), root_layer->bounds());
       EndTest();
     }
   }
 
  private:
   SetBoundsClient client_;
   int num_commits_;
 };
 
-SINGLE_THREAD_TEST_F(LayerTreeHostTestChangeLayerPropertiesInPaintContents);
+SINGLE_THREAD_NOIMPL_TEST_F(

[danakj, 2014/09/03 17:01:32]

can this be SINGLE_AND_MULTI_IMPL after all that?

[enne (OOO), 2014/09/03 19:41:28]

Made it SINGLE_AND_MULTI instead.

+    LayerTreeHostTestChangeLayerPropertiesInPaintContents);
 
 class MockIOSurfaceWebGraphicsContext3D : public TestWebGraphicsContext3D {
  public:
   MockIOSurfaceWebGraphicsContext3D() {
     test_capabilities_.gpu.iosurface = true;
     test_capabilities_.gpu.texture_rectangle = true;
   }
 
   virtual GLuint createTexture() OVERRIDE {
     return 1;
@@ skipping 2586 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