cc: Change LayerTreeHost unit tests to use impl painting.

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 256 matching lines @@
   int num_draws_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestSetNeedsRedraw);
 
 // After setNeedsRedrawRect(invalid_rect) the final damage_rect
 // must contain invalid_rect.
 class LayerTreeHostTestSetNeedsRedrawRect : public LayerTreeHostTest {
  public:
   LayerTreeHostTestSetNeedsRedrawRect()
-      : num_draws_(0),
-        bounds_(50, 50),
-        invalid_rect_(10, 10, 20, 20),
-        root_layer_(ContentLayer::Create(&client_)) {}
+      : num_draws_(0), bounds_(50, 50), invalid_rect_(10, 10, 20, 20) {}
 
   virtual void BeginTest() OVERRIDE {
+    if (layer_tree_host()->settings().impl_side_painting)
+      root_layer_ = FakePictureLayer::Create(&client_);
+    else
+      root_layer_ = ContentLayer::Create(&client_);
+
     root_layer_->SetIsDrawable(true);
     root_layer_->SetBounds(bounds_);
     layer_tree_host()->SetRootLayer(root_layer_);
     layer_tree_host()->SetViewportSize(bounds_);
     PostSetNeedsCommitToMainThread();
   }
 
   virtual DrawResult PrepareToDrawOnThread(
       LayerTreeHostImpl* host_impl,
       LayerTreeHostImpl::FrameData* frame_data,
@@ skipping 24 matching lines @@
     num_draws_++;
   }
 
   virtual void AfterTest() OVERRIDE { EXPECT_EQ(2, num_draws_); }
 
  private:
   int num_draws_;
   const gfx::Size bounds_;
   const gfx::Rect invalid_rect_;
   FakeContentLayerClient client_;
-  scoped_refptr<ContentLayer> root_layer_;
+  scoped_refptr<Layer> root_layer_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestSetNeedsRedrawRect);
 
 class LayerTreeHostTestNoExtraCommitFromInvalidate : public LayerTreeHostTest {
  public:
   virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
     settings->layer_transforms_should_scale_layer_contents = true;
   }
 
@@ skipping 98 matching lines @@
   scoped_refptr<Layer> root_layer_;
   scoped_refptr<FakePaintedScrollbarLayer> scrollbar_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostTestNoExtraCommitFromScrollbarInvalidate);
 
 class LayerTreeHostTestSetNextCommitForcesRedraw : public LayerTreeHostTest {
  public:
   LayerTreeHostTestSetNextCommitForcesRedraw()
-      : num_draws_(0),
-        bounds_(50, 50),
-        invalid_rect_(10, 10, 20, 20),
-        root_layer_(ContentLayer::Create(&client_)) {}
+      : num_draws_(0), bounds_(50, 50), invalid_rect_(10, 10, 20, 20) {}
 
   virtual void BeginTest() OVERRIDE {
+    if (layer_tree_host()->settings().impl_side_painting)
+      root_layer_ = FakePictureLayer::Create(&client_);
+    else
+      root_layer_ = ContentLayer::Create(&client_);
+
     root_layer_->SetIsDrawable(true);
     root_layer_->SetBounds(bounds_);
     layer_tree_host()->SetRootLayer(root_layer_);
     layer_tree_host()->SetViewportSize(bounds_);
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
     if (num_draws_ == 3 && host_impl->settings().impl_side_painting)
       host_impl->SetNeedsRedrawRect(invalid_rect_);
@@ skipping 57 matching lines @@
     num_draws_++;
   }
 
   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_;
+  scoped_refptr<Layer> root_layer_;
 };
 
 SINGLE_AND_MULTI_THREAD_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_)) {}
+  LayerTreeHostTestUndrawnLayersDamageLater() {}
 
   virtual void SetupTree() OVERRIDE {
+    if (layer_tree_host()->settings().impl_side_painting)
+      root_layer_ = FakePictureLayer::Create(&client_);
+    else
+      root_layer_ = ContentLayer::Create(&client_);
+
     root_layer_->SetIsDrawable(true);
     root_layer_->SetBounds(gfx::Size(50, 50));
     layer_tree_host()->SetRootLayer(root_layer_);
 
     // The initially transparent layer has a larger child layer, which is
     // not initially drawn because of the this (parent) layer.
-    parent_layer_ = FakeContentLayer::Create(&client_);
+    if (layer_tree_host()->settings().impl_side_painting)
+      parent_layer_ = FakePictureLayer::Create(&client_);
+    else
+      parent_layer_ = FakeContentLayer::Create(&client_);
+
     parent_layer_->SetBounds(gfx::Size(15, 15));
     parent_layer_->SetOpacity(0.0f);
     root_layer_->AddChild(parent_layer_);
 
-    child_layer_ = FakeContentLayer::Create(&client_);
+    if (layer_tree_host()->settings().impl_side_painting)
+      child_layer_ = FakePictureLayer::Create(&client_);
+    else
+      child_layer_ = FakeContentLayer::Create(&client_);
+
     child_layer_->SetBounds(gfx::Size(25, 25));
     parent_layer_->AddChild(child_layer_);
 
     LayerTreeHostTest::SetupTree();
   }
 
   virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 
   virtual DrawResult PrepareToDrawOnThread(
       LayerTreeHostImpl* host_impl,
@@ skipping 45 matching lines @@
         break;
       default:
         NOTREACHED();
     }
   }
 
   virtual void AfterTest() OVERRIDE {}
 
  private:
   FakeContentLayerClient client_;
-  scoped_refptr<ContentLayer> root_layer_;
-  scoped_refptr<FakeContentLayer> parent_layer_;
-  scoped_refptr<FakeContentLayer> child_layer_;
+  scoped_refptr<Layer> root_layer_;
+  scoped_refptr<Layer> parent_layer_;
+  scoped_refptr<Layer> child_layer_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestUndrawnLayersDamageLater);
 
 // Tests that if a layer is not drawn because of some reason in the parent,
 // causing its content bounds to not be computed, then when it is later drawn,
 // its content bounds get pushed.
 class LayerTreeHostTestUndrawnLayersPushContentBoundsLater
     : public LayerTreeHostTest {
  public:
@@ skipping 318 matching lines @@
     if (test_layer_)
       test_layer_->SetOpacity(0.f);
   }
   virtual void DidChangeLayerCanUseLCDText() OVERRIDE {}
   virtual bool FillsBoundsCompletely() const OVERRIDE { return false; }
 
  private:
   Layer* test_layer_;
 };
 
 class ContentLayerWithUpdateTracking : public ContentLayer {

[sohanjg, 2014/09/10 14:11:19]

Do we change this to use PictureLayer ? LayerTreeHostTestContinuousPainting
later on tests with this class for non-impl side painting too.

[danakj, 2014/09/10 15:24:29]

Ya, leave this class alone, and just use FakePictureLayer instead as that test
does for impl-side.

[sohanjg, 2014/09/15 10:38:39]

Acknowledged.

  public:
   static scoped_refptr<ContentLayerWithUpdateTracking> Create(
       ContentLayerClient* client) {
     return make_scoped_refptr(new ContentLayerWithUpdateTracking(client));
   }
 
   int PaintContentsCount() { return paint_contents_count_; }
   void ResetPaintContentsCount() { paint_contents_count_ = 0; }
 
   virtual bool Update(ResourceUpdateQueue* queue,
                       const OcclusionTracker<Layer>* occlusion) OVERRIDE {
     bool updated = ContentLayer::Update(queue, occlusion);
     paint_contents_count_++;
     return updated;
   }
 
  private:
   explicit ContentLayerWithUpdateTracking(ContentLayerClient* client)
       : ContentLayer(client), paint_contents_count_(0) {
     SetBounds(gfx::Size(10, 10));
     SetIsDrawable(true);
   }
   virtual ~ContentLayerWithUpdateTracking() {}
 
   int paint_contents_count_;
 };
 
 // Layer opacity change during paint should not prevent compositor resources
 // from being updated during commit.
 class LayerTreeHostTestOpacityChange : public LayerTreeHostTest {

[sohanjg, 2014/09/10 14:11:18]

LayerTreeHostTestOpacityChange looks to be valid only for non-impl painting ?
Should we change this ?

[danakj, 2014/09/10 15:24:29]

Ya let's change this. Blink could change the opacity during paint in implside
too.

[sohanjg, 2014/09/15 10:38:39]

Acknowledged.

  public:
   LayerTreeHostTestOpacityChange()
       : test_opacity_change_delegate_(),
         update_check_layer_(ContentLayerWithUpdateTracking::Create(
             &test_opacity_change_delegate_)) {
     test_opacity_change_delegate_.SetTestLayer(update_check_layer_.get());
   }
 
   virtual void BeginTest() OVERRIDE {
     layer_tree_host()->SetViewportSize(gfx::Size(10, 10));
@@ skipping 11 matching lines @@
     EXPECT_EQ(1, update_check_layer_->PaintContentsCount());
   }
 
  private:
   TestOpacityChangeLayerDelegate test_opacity_change_delegate_;
   scoped_refptr<ContentLayerWithUpdateTracking> update_check_layer_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestOpacityChange);
 
-class NoScaleContentLayer : public ContentLayer {
+class NoScalePictureLayer : public PictureLayer {
  public:
-  static scoped_refptr<NoScaleContentLayer> Create(ContentLayerClient* client) {
-    return make_scoped_refptr(new NoScaleContentLayer(client));
+  static scoped_refptr<NoScalePictureLayer> Create(ContentLayerClient* client) {
+    return make_scoped_refptr(new NoScalePictureLayer(client));
   }
 
   virtual void CalculateContentsScale(float ideal_contents_scale,
                                       float* contents_scale_x,
                                       float* contents_scale_y,
                                       gfx::Size* contentBounds) OVERRIDE {
     // Skip over the ContentLayer's method to the base Layer class.
     Layer::CalculateContentsScale(ideal_contents_scale,
                                   contents_scale_x,
                                   contents_scale_y,
                                   contentBounds);
   }
 
  private:
-  explicit NoScaleContentLayer(ContentLayerClient* client)
-      : ContentLayer(client) {}
-  virtual ~NoScaleContentLayer() {}
+  explicit NoScalePictureLayer(ContentLayerClient* client)
+      : PictureLayer(client) {}
+  virtual ~NoScalePictureLayer() {}
 };
 
 class LayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers
     : public LayerTreeHostTest {
  public:
   LayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers()
-      : root_layer_(NoScaleContentLayer::Create(&client_)),
-        child_layer_(ContentLayer::Create(&client_)) {}
+      : root_layer_(NoScalePictureLayer::Create(&client_)),
+        child_layer_(PictureLayer::Create(&client_)) {}
 
   virtual void BeginTest() OVERRIDE {
     layer_tree_host()->SetViewportSize(gfx::Size(60, 60));
     layer_tree_host()->SetDeviceScaleFactor(1.5);
     EXPECT_EQ(gfx::Size(60, 60), layer_tree_host()->device_viewport_size());
 
     root_layer_->AddChild(child_layer_);
 
     root_layer_->SetIsDrawable(true);
     root_layer_->SetBounds(gfx::Size(30, 30));
@@ skipping 40 matching lines @@
               render_surface_layer_list[0]->render_surface());
     ASSERT_EQ(2u, root->render_surface()->layer_list().size());
 
     // The root render surface is the size of the viewport.
     EXPECT_RECT_EQ(gfx::Rect(0, 0, 60, 60),
                    root->render_surface()->content_rect());
 
     // The content bounds of the child should be scaled.
     gfx::Size child_bounds_scaled =
         gfx::ToCeiledSize(gfx::ScaleSize(child->bounds(), 1.5));
     EXPECT_EQ(child_bounds_scaled, child->content_bounds());

[sohanjg, 2014/09/11 14:53:57]

when using picturelayer the content_bounds, are not scaled by the device scale
factor here, is that a bug?

[danakj, 2014/09/11 17:17:30]

No, that's the change you made to picture layer to make its contents scale
always 1. You need to check the MaxTilingContentScale() instead.

[sohanjg, 2014/09/15 10:38:39]

Acknowledged.

 
     gfx::Transform scale_transform;
     scale_transform.Scale(impl->device_scale_factor(),
                           impl->device_scale_factor());
 
     // The root layer is scaled by 2x.
     gfx::Transform root_screen_space_transform = scale_transform;
     gfx::Transform root_draw_transform = scale_transform;
 
     EXPECT_EQ(root_draw_transform, root->draw_transform());
     EXPECT_EQ(root_screen_space_transform, root->screen_space_transform());
 

[sohanjg, 2014/09/11 14:53:57]

when using picturelayer the transforms, are not scaled by the device scale
factor here, is that a bug?

     // The child is at position 2,2, which is transformed to 3,3 after the scale
     gfx::Transform child_screen_space_transform;
     child_screen_space_transform.Translate(3.f, 3.f);
     gfx::Transform child_draw_transform = child_screen_space_transform;
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(child_draw_transform,
                                     child->draw_transform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(child_screen_space_transform,
                                     child->screen_space_transform());
 
     EndTest();
   }
 
   virtual void AfterTest() OVERRIDE {}
 
  private:
   FakeContentLayerClient client_;
-  scoped_refptr<NoScaleContentLayer> root_layer_;
-  scoped_refptr<ContentLayer> child_layer_;
+  scoped_refptr<NoScalePictureLayer> root_layer_;
+  scoped_refptr<PictureLayer> child_layer_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers);

[danakj, 2014/09/10 15:24:29]

Does this test work? I'm a bit surprised you can activate a picture layer when
impl-side painting is turned off XD. Anyhow can you change this to the IMPL
version of the macro so it only runs with impl-side. PicturLayer + non-impl side
doesn't mean much.

[sohanjg, 2014/09/15 10:38:39]

Acknowledged.

 
 // Verify atomicity of commits and reuse of textures.
 class LayerTreeHostTestDirectRendererAtomicCommit : public LayerTreeHostTest {

[danakj, 2014/09/10 15:24:29]

This test doesn't make sense for impl-side you can leave it NOIMPL and TODO() to
remove it once impl-side ships everywhere (looks like m39 *cross fingers*)

[sohanjg, 2014/09/15 10:38:39]

Acknowledged.

  public:
   virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
     settings->texture_id_allocation_chunk_size = 1;
     // Make sure partial texture updates are turned off.
     settings->max_partial_texture_updates = 0;
     // Linear fade animator prevents scrollbars from drawing immediately.
     settings->scrollbar_animator = LayerTreeSettings::NoAnimator;
   }
 
   virtual void SetupTree() OVERRIDE {
-    layer_ = FakeContentLayer::Create(&client_);
+    layer_ = FakePictureLayer::Create(&client_);
     layer_->SetBounds(gfx::Size(10, 20));
 
     bool paint_scrollbar = true;
     bool has_thumb = false;
     scrollbar_ = FakePaintedScrollbarLayer::Create(
         paint_scrollbar, has_thumb, layer_->id());
     scrollbar_->SetPosition(gfx::Point(0, 10));
     scrollbar_->SetBounds(gfx::Size(10, 10));
 
     layer_->AddChild(scrollbar_);
@@ skipping 67 matching lines @@
 
   virtual void Layout() OVERRIDE {
     layer_->SetNeedsDisplay();
     scrollbar_->SetNeedsDisplay();
   }
 
   virtual void AfterTest() OVERRIDE {}
 
  protected:
   FakeContentLayerClient client_;
-  scoped_refptr<FakeContentLayer> layer_;
+  scoped_refptr<FakePictureLayer> layer_;
   scoped_refptr<FakePaintedScrollbarLayer> scrollbar_;
   int drew_frame_;
 };
 
-MULTI_THREAD_DIRECT_RENDERER_NOIMPL_TEST_F(
-    LayerTreeHostTestDirectRendererAtomicCommit);
+TEST_F(LayerTreeHostTestDirectRendererAtomicCommit,
+       RunMultiThread_DirectRenderer_ImplSidePaint) {
+  RunTest(true, false, true);
+}
 
 class LayerTreeHostTestDelegatingRendererAtomicCommit
     : public LayerTreeHostTestDirectRendererAtomicCommit {
  public:
   virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     ASSERT_EQ(0u, layer_tree_host()->settings().max_partial_texture_updates);
 
     TestWebGraphicsContext3D* context = TestContext();
 
     switch (impl->active_tree()->source_frame_number()) {
@@ skipping 3770 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