Turn off computation of the interest rect in cc in synchronized paint mode.

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/location.h"
@@ skipping 245 matching lines @@
  public:
   void SetupTree() override {
     client_.set_fill_with_nonsolid_color(true);
     scoped_refptr<FakePictureLayer> root_layer =
         FakePictureLayer::Create(layer_settings(), &client_);
     root_layer->SetBounds(gfx::Size(1024, 1024));
     root_layer->SetIsDrawable(true);
 
     layer_tree_host()->SetRootLayer(root_layer);
     LayerTreeHostTest::SetupTree();
+    client_.set_bounds(root_layer->bounds());
   }
 
   void AfterTest() override {
     EXPECT_TRUE(did_notify_ready_to_activate_);
     EXPECT_TRUE(all_tiles_required_for_activation_are_ready_to_draw_);
     EXPECT_LE(size_t(1), required_for_activation_count_);
   }
 
  private:
   FakeContentLayerClient client_;
@@ skipping 50 matching lines @@
  public:
   void SetupTree() override {
     client_.set_fill_with_nonsolid_color(true);
     scoped_refptr<FakePictureLayer> root_layer =
         FakePictureLayer::Create(layer_settings(), &client_);
     root_layer->SetBounds(gfx::Size(1024, 1024));
     root_layer->SetIsDrawable(true);
 
     layer_tree_host()->SetRootLayer(root_layer);
     LayerTreeHostTest::SetupTree();
+    client_.set_bounds(root_layer->bounds());
   }
 
   void AfterTest() override {
     EXPECT_TRUE(did_notify_ready_to_draw_);
     EXPECT_TRUE(all_tiles_required_for_draw_are_ready_to_draw_);
     EXPECT_LE(size_t(1), required_for_draw_count_);
   }
 
  private:
   FakeContentLayerClient client_;
@@ skipping 13 matching lines @@
         did_notify_ready_to_draw_(false),
         did_draw_(false) {}
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void SetupTree() override {
     client_.set_fill_with_nonsolid_color(true);
     scoped_refptr<FakePictureLayer> root_layer =
         FakePictureLayer::Create(layer_settings(), &client_);
     root_layer->SetBounds(gfx::Size(1024, 1024));
+    client_.set_bounds(root_layer->bounds());
     root_layer->SetIsDrawable(true);
 
     layer_tree_host()->SetRootLayer(root_layer);
     LayerTreeHostTest::SetupTree();
   }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     if (!toggled_visibility_) {
       {
         DebugScopedSetMainThread main(task_runner_provider());
@@ skipping 345 matching lines @@
   LayerTreeHostTestSetNeedsRedrawRect()
       : num_draws_(0), bounds_(50, 50), invalid_rect_(10, 10, 20, 20) {}
 
   void BeginTest() override {
     root_layer_ = FakePictureLayer::Create(layer_settings(), &client_);
     root_layer_->SetIsDrawable(true);
     root_layer_->SetBounds(bounds_);
     layer_tree_host()->SetRootLayer(root_layer_);
     layer_tree_host()->SetViewportSize(bounds_);
     PostSetNeedsCommitToMainThread();
+    client_.set_bounds(root_layer_->bounds());
   }
 
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                    LayerTreeHostImpl::FrameData* frame_data,
                                    DrawResult draw_result) override {
     EXPECT_EQ(DRAW_SUCCESS, draw_result);
 
     gfx::Rect root_damage_rect;
     if (!frame_data->render_passes.empty())
       root_damage_rect = frame_data->render_passes.back()->damage_rect;
@@ skipping 44 matching lines @@
     gfx::Transform transform;
     // Translate the layer out of the viewport to force it to not update its
     // tile size via PushProperties.
     transform.Translate(10000.0, 10000.0);
     root_layer_->SetTransform(transform);
     root_layer_->SetBounds(bounds_);
     layer_tree_host()->SetRootLayer(root_layer_);
     layer_tree_host()->SetViewportSize(bounds_);
 
     PostSetNeedsCommitToMainThread();
+    client_.set_bounds(root_layer_->bounds());
   }
 
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->gpu_rasterization_enabled = true;
     settings->gpu_rasterization_forced = true;
   }
 
   void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     // Perform 2 commits.
     if (!num_draws_) {
@@ skipping 54 matching lines @@
   void SetupTree() override {
     root_layer_ = Layer::Create(layer_settings());
     root_layer_->SetBounds(gfx::Size(10, 20));
 
     scaled_layer_ = FakePictureLayer::Create(layer_settings(), &client_);
     scaled_layer_->SetBounds(gfx::Size(1, 1));
     root_layer_->AddChild(scaled_layer_);
 
     layer_tree_host()->SetRootLayer(root_layer_);
     LayerTreeHostTest::SetupTree();
+    client_.set_bounds(root_layer_->bounds());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override {
     if (host_impl->active_tree()->source_frame_number() == 1)
       EndTest();
   }
 
   void DidCommit() override {
@@ skipping 35 matching lines @@
     bool has_thumb = false;
     scrollbar_ = FakePaintedScrollbarLayer::Create(
         layer_settings(), paint_scrollbar, has_thumb, root_layer_->id());
     scrollbar_->SetPosition(gfx::PointF(0.f, 10.f));
     scrollbar_->SetBounds(gfx::Size(10, 10));
 
     root_layer_->AddChild(scrollbar_);
 
     layer_tree_host()->SetRootLayer(root_layer_);
     LayerTreeHostTest::SetupTree();
+    client_.set_bounds(root_layer_->bounds());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override {
     if (host_impl->active_tree()->source_frame_number() == 1)
       EndTest();
   }
 
   void DidCommit() override {
@@ skipping 32 matching lines @@
   void SetupTree() override {
     root_layer_ = Layer::Create(layer_settings());
     root_layer_->SetBounds(gfx::Size(10, 20));
 
     child_layer_ = FakePictureLayer::Create(layer_settings(), &client_);
     child_layer_->SetBounds(gfx::Size(10, 10));
     root_layer_->AddChild(child_layer_);
 
     layer_tree_host()->SetRootLayer(root_layer_);
     LayerTreeHostTest::SetupTree();
+    client_.set_bounds(root_layer_->bounds());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommit() override {
     if (layer_tree_host()->source_frame_number() == 1)
       layer_tree_host()->SetDeviceScaleFactor(4.f);
   }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
@@ skipping 39 matching lines @@
   LayerTreeHostTestSetNextCommitForcesRedraw()
       : num_draws_(0), bounds_(50, 50), invalid_rect_(10, 10, 20, 20) {}
 
   void BeginTest() override {
     root_layer_ = FakePictureLayer::Create(layer_settings(), &client_);
     root_layer_->SetIsDrawable(true);
     root_layer_->SetBounds(bounds_);
     layer_tree_host()->SetRootLayer(root_layer_);
     layer_tree_host()->SetViewportSize(bounds_);
     PostSetNeedsCommitToMainThread();
+    client_.set_bounds(root_layer_->bounds());
   }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     if (num_draws_ == 3)
       host_impl->SetNeedsRedrawRect(invalid_rect_);
   }
 
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                    LayerTreeHostImpl::FrameData* frame_data,
                                    DrawResult draw_result) override {
@@ skipping 81 matching lines @@
     // The initially transparent layer has a larger child layer, which is
     // not initially drawn because of the this (parent) layer.
     parent_layer_ = FakePictureLayer::Create(layer_settings(), &client_);
     parent_layer_->SetBounds(gfx::Size(15, 15));
     parent_layer_->SetOpacity(0.0f);
     root_layer_->AddChild(parent_layer_);
 
     child_layer_ = FakePictureLayer::Create(layer_settings(), &client_);
     child_layer_->SetBounds(gfx::Size(25, 25));
     parent_layer_->AddChild(child_layer_);
+    client_.set_bounds(root_layer_->bounds());
 
     LayerTreeHostTest::SetupTree();
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                    LayerTreeHostImpl::FrameData* frame_data,
                                    DrawResult draw_result) override {
     EXPECT_EQ(DRAW_SUCCESS, draw_result);
@@ skipping 74 matching lines @@
     recording.reset(new FakeDisplayListRecordingSource);
     child_layer_ = FakePictureLayer::CreateWithRecordingSource(
         layer_settings(), &client_, std::move(recording));
     child_layer_->SetBounds(gfx::Size(25, 25));
     child_layer_->SetIsDrawable(true);
     child_layer_->SetContentsOpaque(true);
     root_layer_->AddChild(child_layer_);
 
     layer_tree_host()->SetRootLayer(root_layer_);
     LayerTreeHostTest::SetupTree();
+    client_.set_bounds(root_layer_->bounds());
   }
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     // Force the layer to have a tiling at 1.3f scale. Note that if we simply
     // add tiling, it will be gone by the time we draw because of aggressive
     // cleanup. AddTilingUntilNextDraw ensures that it remains there during
     // damage calculation.
     FakePictureLayerImpl* child_layer_impl = static_cast<FakePictureLayerImpl*>(
         host_impl->active_tree()->LayerById(child_layer_->id()));
     child_layer_impl->AddTilingUntilNextDraw(1.3f);
@@ skipping 219 matching lines @@
     scroll_layer_->SetScrollOffset(gfx::ScrollOffset());
 
     CreateVirtualViewportLayers(root_layer,
                                 scroll_layer_,
                                 root_layer->bounds(),
                                 root_layer->bounds(),
                                 layer_tree_host(),
                                 layer_settings());
 
     layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 0.5f, 2.f);
+    client_.set_bounds(root_layer->bounds());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void ApplyViewportDeltas(const gfx::Vector2dF& scroll_delta,
                            const gfx::Vector2dF&,
                            const gfx::Vector2dF& elastic_overscroll_delta,
                            float scale,
                            float) override {
     gfx::ScrollOffset offset = scroll_layer_->scroll_offset();
@@ skipping 66 matching lines @@
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestSetVisible);
 
 class TestOpacityChangeLayerDelegate : public ContentLayerClient {
  public:
   TestOpacityChangeLayerDelegate() : test_layer_(0) {}
 
   void SetTestLayer(Layer* test_layer) { test_layer_ = test_layer; }
 
+  gfx::Rect PaintableRegion() override {
+    return gfx::Rect(test_layer_->bounds());
+  }
   scoped_refptr<DisplayItemList> PaintContentsToDisplayList(
       const gfx::Rect& clip,
       PaintingControlSetting picture_control) override {
     // Set layer opacity to 0.
     if (test_layer_)
       test_layer_->SetOpacity(0.f);
 
     // Return a dummy display list.
     scoped_refptr<DisplayItemList> display_list =
         DisplayItemList::Create(clip, DisplayItemListSettings());
@@ skipping 53 matching lines @@
     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));
 
     child_layer_->SetIsDrawable(true);
     child_layer_->SetPosition(gfx::PointF(2.f, 2.f));
     child_layer_->SetBounds(gfx::Size(10, 10));
+    client_.set_bounds(gfx::Size(10, 10));
 
     layer_tree_host()->SetRootLayer(root_layer_);
 
     PostSetNeedsCommitToMainThread();
+    client_.set_bounds(root_layer_->bounds());
   }
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* impl) override {
     // Should only do one commit.
     EXPECT_EQ(0, impl->active_tree()->source_frame_number());
     // Device scale factor should come over to impl.
     EXPECT_NEAR(impl->active_tree()->device_scale_factor(), 1.5f, 0.00001f);
 
     // Both layers are on impl.
     ASSERT_EQ(1u, impl->active_tree()->root_layer()->children().size());
@@ skipping 73 matching lines @@
     layer_tree_host()->SetViewportSize(gfx::Size(10, 10));
     layer_tree_host()->root_layer()->SetBounds(gfx::Size(10, 10));
 
     layer_ = FakePictureLayer::Create(layer_settings(), &client_);
     layer_->SetBounds(gfx::Size(10, 10));
     layer_->SetPosition(gfx::PointF(0.f, 0.f));
     layer_->SetIsDrawable(true);
     layer_tree_host()->root_layer()->AddChild(layer_);
 
     PostSetNeedsCommitToMainThread();
+    client_.set_bounds(layer_->bounds());
   }
 
   void DidCommitAndDrawFrame() override {
     if (num_draw_layers_ == 2)
       return;
     layer_->SetNeedsDisplay();
   }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
     if (num_draw_layers_ == 1)
@@ skipping 161 matching lines @@
     root_layer->SetBounds(gfx::Size(10, 10));
     root_layer->SetContentsOpaque(true);
 
     layer_tree_host()->SetRootLayer(root_layer);
 
     // The expectations are based on the assumption that the default
     // LCD settings are:
     EXPECT_TRUE(layer_tree_host()->settings().can_use_lcd_text);
 
     LayerTreeHostTest::SetupTree();
+    client_.set_bounds(root_layer->bounds());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommitAndDrawFrame() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         PostSetNeedsCommitToMainThread();
         break;
       case 2:
@@ skipping 205 matching lines @@
     : public LayerTreeHostTest {
  protected:
   void SetupTree() override {
     LayerTreeHostTest::SetupTree();
 
     scoped_refptr<Layer> layer =
         PictureLayer::Create(layer_settings(), &client_);
     layer->SetTransform(gfx::Transform(0.0, 0.0, 0.0, 0.0, 0.0, 0.0));
     layer->SetBounds(gfx::Size(10, 10));
     layer_tree_host()->root_layer()->AddChild(layer);
+    client_.set_bounds(layer->bounds());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     EndTest();
   }
 
   void AfterTest() override {}
 
   FakeContentLayerClient client_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostTestUninvertibleTransformDoesNotBlockActivation);
 
 class LayerTreeHostTestChangeLayerPropertiesInPaintContents
     : public LayerTreeHostTest {
  public:
   class SetBoundsClient : public ContentLayerClient {
    public:
     SetBoundsClient() : layer_(0) {}
 
     void set_layer(Layer* layer) { layer_ = layer; }
 
+    gfx::Rect PaintableRegion() override { return gfx::Rect(layer_->bounds()); }
+
     scoped_refptr<DisplayItemList> PaintContentsToDisplayList(
         const gfx::Rect& clip,
         PaintingControlSetting picture_control) override {
       layer_->SetBounds(gfx::Size(2, 2));
 
       // Return a dummy display list.
       scoped_refptr<DisplayItemList> display_list =
           DisplayItemList::Create(clip, DisplayItemListSettings());
       return display_list;
     }
@@ skipping 245 matching lines @@
 
     child_layer_ = FakePictureLayer::Create(layer_settings(), &client_);
     child_layer_->SetIsDrawable(true);
     child_layer_->SetBounds(gfx::Size(50, 50));
 
     root_layer_->AddChild(parent_layer_);
     parent_layer_->AddChild(child_layer_);
     layer_tree_host()->SetRootLayer(root_layer_);
 
     LayerTreeHostTest::SetupTree();
+    client_.set_bounds(root_layer_->bounds());
   }
 
   scoped_ptr<FakeOutputSurface> CreateFakeOutputSurface() override {
     if (delegating_renderer()) {
       return FakeOutputSurface::CreateDelegatingSoftware(
           make_scoped_ptr(new SoftwareOutputDevice));
     } else {
       return FakeOutputSurface::CreateSoftware(
           make_scoped_ptr(new SoftwareOutputDevice));
     }
@@ skipping 251 matching lines @@
 
     root_->AddChild(child_);
     root_->AddChild(child2_);
     child_->AddChild(grandchild_);
     child2_->AddChild(leaf_always_pushing_layer_);
 
     other_root_ = PushPropertiesCountingLayer::Create(layer_settings());
 
     // Don't set the root layer here.
     LayerTreeHostTest::SetupTree();
+    client_.set_bounds(root_->bounds());
   }
 
   void DidCommitAndDrawFrame() override {
     EXPECT_EQ(expected_push_properties_root_, root_->push_properties_count())
         << "num_commits: " << num_commits_;
     EXPECT_EQ(expected_push_properties_child_, child_->push_properties_count())
         << "num_commits: " << num_commits_;
     EXPECT_EQ(expected_push_properties_grandchild_,
               grandchild_->push_properties_count())
         << "num_commits: " << num_commits_;
@@ skipping 483 matching lines @@
     grandchild2_ = PushPropertiesCountingLayer::Create(layer_settings());
     grandchild3_ = PushPropertiesCountingLayer::Create(layer_settings());
 
     root_->AddChild(child_);
     child_->AddChild(grandchild1_);
     child_->AddChild(grandchild2_);
     child_->AddChild(grandchild3_);
 
     // Don't set the root layer here.
     LayerTreeHostTest::SetupTree();
+    client_.set_bounds(root_->bounds());
   }
 
   void AfterTest() override {}
 
   FakeContentLayerClient client_;
   scoped_refptr<PushPropertiesCountingLayer> root_;
   scoped_refptr<PushPropertiesCountingLayer> child_;
   scoped_refptr<PushPropertiesCountingLayer> grandchild1_;
   scoped_refptr<PushPropertiesCountingLayer> grandchild2_;
   scoped_refptr<PushPropertiesCountingLayer> grandchild3_;
@@ skipping 583 matching lines @@
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestPushHiddenLayer);
 
 class LayerTreeHostTestUpdateLayerInEmptyViewport : public LayerTreeHostTest {
  protected:
   void SetupTree() override {
     root_layer_ = FakePictureLayer::Create(layer_settings(), &client_);
     root_layer_->SetBounds(gfx::Size(10, 10));
 
     layer_tree_host()->SetRootLayer(root_layer_);
     LayerTreeHostTest::SetupTree();
+    client_.set_bounds(root_layer_->bounds());
   }
 
   void BeginTest() override {
     // The viewport is empty, but we still need to update layers on the main
     // thread.
     layer_tree_host()->SetViewportSize(gfx::Size(0, 0));
     PostSetNeedsCommitToMainThread();
   }
 
   void DidCommit() override {
@@ skipping 41 matching lines @@
             gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE,
             ManagedMemoryPolicy::kDefaultNumResourcesLimit)));
     return output_surface;
   }
 
   void SetupTree() override {
     root_ = FakePictureLayer::Create(layer_settings(), &client_);
     root_->SetBounds(gfx::Size(20, 20));
     layer_tree_host()->SetRootLayer(root_);
     LayerTreeHostTest::SetupTree();
+    client_.set_bounds(root_->bounds());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommitAndDrawFrame() override {
     // Lost context sometimes takes two frames to recreate. The third frame
     // is sometimes aborted, so wait until the fourth frame to verify that
     // the memory has been set, and the fifth frame to end the test.
     if (layer_tree_host()->source_frame_number() < 5) {
       layer_tree_host()->SetNeedsCommit();
@@ skipping 497 matching lines @@
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestSimpleSwapPromiseMonitor);
 
 class LayerTreeHostTestHighResRequiredAfterEvictingUIResources
     : public LayerTreeHostTest {
  protected:
   void SetupTree() override {
     LayerTreeHostTest::SetupTree();
     ui_resource_ = FakeScopedUIResource::Create(layer_tree_host());
+    client_.set_bounds(layer_tree_host()->root_layer()->bounds());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     host_impl->EvictAllUIResources();
     // Existence of evicted UI resources will trigger NEW_CONTENT_TAKES_PRIORITY
     // mode. Active tree should require high-res to draw after entering this
     // mode to ensure that high-res tiles are also required for a pending tree
     // to be activated.
@@ skipping 36 matching lines @@
         new FakeDisplayListRecordingSource);
     recording_source_ = recording_source.get();
 
     scoped_refptr<FakePictureLayer> layer =
         FakePictureLayer::CreateWithRecordingSource(
             layer_settings(), &layer_client_, std::move(recording_source));
     layer_ = layer.get();
     layer->SetBounds(gfx::Size(10, 10));
     layer->SetIsDrawable(true);
     layer_tree_host()->root_layer()->AddChild(layer);
+    layer_client_.set_bounds(layer_->bounds());
   }
 
   void BeginTest() override {
     // Verify default value.
     EXPECT_FALSE(layer_tree_host()->has_gpu_rasterization_trigger());
 
     // Setting gpu rasterization trigger does not enable gpu rasterization.
     layer_tree_host()->SetHasGpuRasterizationTrigger(true);
     EXPECT_TRUE(layer_tree_host()->has_gpu_rasterization_trigger());
 
@@ skipping 35 matching lines @@
         new FakeDisplayListRecordingSource);
     recording_source_ = recording_source.get();
 
     scoped_refptr<FakePictureLayer> layer =
         FakePictureLayer::CreateWithRecordingSource(
             layer_settings(), &layer_client_, std::move(recording_source));
     layer_ = layer.get();
     layer->SetBounds(gfx::Size());
     layer->SetIsDrawable(true);
     layer_tree_host()->root_layer()->AddChild(layer);
+    layer_client_.set_bounds(layer->bounds());
   }
 
   void BeginTest() override {
     // Setting gpu rasterization trigger does not enable gpu rasterization.
     layer_tree_host()->SetHasGpuRasterizationTrigger(true);
     EXPECT_TRUE(layer_tree_host()->has_gpu_rasterization_trigger());
 
     PostSetNeedsCommitToMainThread();
   }
 
@@ skipping 37 matching lines @@
         new FakeDisplayListRecordingSource);
     recording_source_ = recording_source.get();
 
     scoped_refptr<FakePictureLayer> layer =
         FakePictureLayer::CreateWithRecordingSource(
             layer_settings(), &layer_client_, std::move(recording_source));
     layer_ = layer.get();
     layer->SetBounds(gfx::Size(10, 10));
     layer->SetIsDrawable(true);
     layer_tree_host()->root_layer()->AddChild(layer);
+    layer_client_.set_bounds(layer_->bounds());
   }
 
   void BeginTest() override {
     // Verify default value.
     EXPECT_FALSE(layer_tree_host()->has_gpu_rasterization_trigger());
 
     // Gpu rasterization trigger is relevant.
     layer_tree_host()->SetHasGpuRasterizationTrigger(true);
     EXPECT_TRUE(layer_tree_host()->has_gpu_rasterization_trigger());
 
@@ skipping 50 matching lines @@
     recording_source_ = recording_source.get();
 
     scoped_refptr<FakePictureLayer> layer =
         FakePictureLayer::CreateWithRecordingSource(
             layer_settings(), &layer_client_, std::move(recording_source));
     layer_ = layer.get();
 
     layer->SetBounds(gfx::Size(10, 10));
     layer->SetIsDrawable(true);
     layer_tree_host()->root_layer()->AddChild(layer);
+    layer_client_.set_bounds(layer_->bounds());
   }
 
   void BeginTest() override {
     // Verify default value.
     EXPECT_FALSE(layer_tree_host()->has_gpu_rasterization_trigger());
 
     // With gpu rasterization forced, gpu rasterization trigger is irrelevant.
     layer_tree_host()->SetHasGpuRasterizationTrigger(true);
     EXPECT_TRUE(layer_tree_host()->has_gpu_rasterization_trigger());
 
@@ skipping 264 matching lines @@
 
   void AfterTest() override {
     // Ensure we activated even though the signal was blocked.
     EXPECT_EQ(1, activation_count_);
     EXPECT_TRUE(visible_);
   }
 
  private:
   int activation_count_;
   bool visible_;
-
-  FakeContentLayerClient client_;
-  scoped_refptr<FakePictureLayer> picture_layer_;
 };
 
 // TODO(vmpstr): Enable with single thread impl-side painting.
 // This test blocks activation which is not supported for single thread mode.
 MULTI_THREAD_BLOCKNOTIFY_TEST_F(LayerTreeHostTestActivateOnInvisible);
 
 // Do a synchronous composite and assert that the swap promise succeeds.
 class LayerTreeHostTestSynchronousCompositeSwapPromise
     : public LayerTreeHostTest {
  public:
@@ skipping 143 matching lines @@
     layer->SetBounds(gfx::Size(500, 500));
     layer->SetContentsOpaque(true);
     // Avoid LCD text on the layer so we don't cause extra commits when we
     // pinch.
     pinch->AddChild(layer);
 
     layer_tree_host()->RegisterViewportLayers(NULL, root, pinch, nullptr);
     layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 1.f, 4.f);
     layer_tree_host()->SetRootLayer(root);
     LayerTreeHostTest::SetupTree();
+    client_.set_bounds(root->bounds());
   }
 
   // Returns the delta scale of all quads in the frame's root pass from their
   // ideal, or 0 if they are not all the same.
   float FrameQuadScaleDeltaFromIdeal(LayerTreeHostImpl::FrameData* frame_data) {
     if (frame_data->has_no_damage)
       return 0.f;
     float frame_scale = 0.f;
     RenderPass* root_pass = frame_data->render_passes.back().get();
     for (const auto& draw_quad : root_pass->quad_list) {
@@ skipping 166 matching lines @@
 
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->gpu_rasterization_forced = true;
   }
 
   void SetupTree() override {
     client_.set_fill_with_nonsolid_color(true);
 
     scoped_refptr<Layer> root = Layer::Create(layer_settings());
     root->SetBounds(gfx::Size(500, 500));
+    client_.set_bounds(root->bounds());
 
     scoped_ptr<FakeDisplayListRecordingSource> recording(
         new FakeDisplayListRecordingSource);
     scoped_refptr<FakePictureLayer> layer =
         FakePictureLayer::CreateWithRecordingSource(layer_settings(), &client_,
                                                     std::move(recording));
     layer->SetBounds(gfx::Size(500, 500));
     layer->SetContentsOpaque(true);
     root->AddChild(layer);
 
     layer_tree_host()->SetRootLayer(root);
     LayerTreeHostTest::SetupTree();
+    client_.set_bounds(root->bounds());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                    LayerTreeHostImpl::FrameData* frame_data,
                                    DrawResult draw_result) override {
     EXPECT_NE(0u, host_impl->resource_provider()->num_resources());
     EndTest();
     return draw_result;
@@ skipping 16 matching lines @@
 
   void SetupTree() override {
     client_.set_fill_with_nonsolid_color(true);
 
     scoped_ptr<FakeDisplayListRecordingSource> recording(
         new FakeDisplayListRecordingSource);
     scoped_refptr<FakePictureLayer> root =
         FakePictureLayer::CreateWithRecordingSource(layer_settings(), &client_,
                                                     std::move(recording));
     root->SetBounds(gfx::Size(10000, 10000));
+    client_.set_bounds(root->bounds());
     root->SetContentsOpaque(true);
 
     layer_tree_host()->SetRootLayer(root);
     LayerTreeHostTest::SetupTree();
     layer_tree_host()->SetViewportSize(viewport_size_);
+    client_.set_bounds(root->bounds());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                    LayerTreeHostImpl::FrameData* frame_data,
                                    DrawResult draw_result) override {
     EXPECT_EQ(10u, host_impl->resource_provider()->num_resources());
     EndTest();
     return draw_result;
@@ skipping 37 matching lines @@
     layer->SetBounds(gfx::Size(500, 500));
     layer->SetContentsOpaque(true);
     // Avoid LCD text on the layer so we don't cause extra commits when we
     // pinch.
     pinch->AddChild(layer);
 
     layer_tree_host()->RegisterViewportLayers(NULL, root, pinch, nullptr);
     layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 1.f, 4.f);
     layer_tree_host()->SetRootLayer(root);
     LayerTreeHostTest::SetupTree();
+    client_.set_bounds(root->bounds());
   }
 
   // Returns the delta scale of all quads in the frame's root pass from their
   // ideal, or 0 if they are not all the same.
   float FrameQuadScaleDeltaFromIdeal(LayerTreeHostImpl::FrameData* frame_data) {
     if (frame_data->has_no_damage)
       return 0.f;
     float frame_scale = 0.f;
     RenderPass* root_pass = frame_data->render_passes.back().get();
     for (const auto& draw_quad : root_pass->quad_list) {
@@ skipping 133 matching lines @@
 
   void SetupTree() override {
     client_.set_fill_with_nonsolid_color(true);
     scoped_refptr<FakePictureLayer> root_layer =
         FakePictureLayer::Create(layer_settings(), &client_);
     root_layer->SetBounds(gfx::Size(1500, 1500));
     root_layer->SetIsDrawable(true);
 
     layer_tree_host()->SetRootLayer(root_layer);
     LayerTreeHostTest::SetupTree();
+    client_.set_bounds(root_layer->bounds());
   }
 
   void BeginTest() override {
     layer_tree_host()->SetViewportSize(gfx::Size(16, 16));
     PostSetNeedsCommitToMainThread();
   }
 
   void InitializedRendererOnThread(LayerTreeHostImpl* host_impl,
                                    bool success) override {
     ASSERT_TRUE(success);
@@ skipping 46 matching lines @@
     child_layer->SetIsDrawable(true);
 
     std::vector<FrameTimingRequest> requests;
     requests.push_back(FrameTimingRequest(1, gfx::Rect(0, 0, 100, 100)));
     requests.push_back(FrameTimingRequest(2, gfx::Rect(300, 0, 100, 100)));
     child_layer->SetFrameTimingRequests(requests);
 
     root_layer->AddChild(child_layer);
     layer_tree_host()->SetRootLayer(root_layer);
     LayerTreeHostTest::SetupTree();
+    client_.set_bounds(root_layer->bounds());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void BeginCommitOnThread(LayerTreeHostImpl* host_impl) override {
     if (!check_results_on_commit_)
       return;
 
     // Since in reality, the events will be read by LayerTreeHost during commit,
     // we check the requests here to ensure that they are correct at the next
@@ skipping 56 matching lines @@
 
   void SetupTree() override {
     client_.set_fill_with_nonsolid_color(true);
     scoped_refptr<FakePictureLayer> root_layer =
         FakePictureLayer::Create(layer_settings(), &client_);
     root_layer->SetBounds(gfx::Size(150, 150));
     root_layer->SetIsDrawable(true);
 
     layer_tree_host()->SetRootLayer(root_layer);
     LayerTreeHostTest::SetupTree();
+    client_.set_bounds(root_layer->bounds());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void NotifyReadyToActivateOnThread(LayerTreeHostImpl* impl) override {
     // Ensure we've already activated.
     EXPECT_FALSE(impl->pending_tree());
 
     // After activating, we either need to prepare tiles, or we've already
     // called a scheduled prepare tiles. This is done because activation might
@@ skipping 134 matching lines @@
     gfx::Size child_size(50, 50);
     content_child_layer->SetBounds(child_size);
     content_child_layer->SetPosition(gfx::PointF(20.f, 0.f));
 
     gfx::Size mask_size(100, 100);
     mask_layer->SetBounds(mask_size);
     mask_layer->SetIsMask(true);
 
     layer_tree_host()->SetRootLayer(root);
     LayerTreeTest::SetupTree();
+    client_.set_bounds(root->bounds());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                    LayerTreeHostImpl::FrameData* frame_data,
                                    DrawResult draw_result) override {
     EXPECT_EQ(2u, frame_data->render_passes.size());
     RenderPass* root_pass = frame_data->render_passes.back().get();
     EXPECT_EQ(2u, root_pass->quad_list.size());
@@ skipping 64 matching lines @@
     scale.Scale(2.f, 2.f);
     scaling_layer->SetTransform(scale);
 
     content_layer->SetBounds(scaling_layer_size);
 
     mask_layer->SetBounds(scaling_layer_size);
     mask_layer->SetIsMask(true);
 
     layer_tree_host()->SetRootLayer(root);
     LayerTreeTest::SetupTree();
+    client_.set_bounds(root->bounds());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                    LayerTreeHostImpl::FrameData* frame_data,
                                    DrawResult draw_result) override {
     EXPECT_EQ(2u, frame_data->render_passes.size());
     RenderPass* root_pass = frame_data->render_passes.back().get();
     EXPECT_EQ(2u, root_pass->quad_list.size());
@@ skipping 68 matching lines @@
 
     gfx::Size layer_size(50, 50);
     content_layer->SetBounds(layer_size);
 
     gfx::Size mask_size(100, 100);
     mask_layer->SetBounds(mask_size);
     mask_layer->SetIsMask(true);
 
     layer_tree_host()->SetRootLayer(root);
     LayerTreeTest::SetupTree();
+    client_.set_bounds(root->bounds());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                    LayerTreeHostImpl::FrameData* frame_data,
                                    DrawResult draw_result) override {
     EXPECT_EQ(2u, frame_data->render_passes.size());
     RenderPass* root_pass = frame_data->render_passes.back().get();
     EXPECT_EQ(2u, root_pass->quad_list.size());
@@ skipping 71 matching lines @@
 
     gfx::Size layer_size(50, 50);
     content_layer->SetBounds(layer_size);
 
     gfx::Size mask_size(100, 100);
     mask_layer->SetBounds(mask_size);
     mask_layer->SetIsMask(true);
 
     layer_tree_host()->SetRootLayer(root);
     LayerTreeTest::SetupTree();
+    client_.set_bounds(root->bounds());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                    LayerTreeHostImpl::FrameData* frame_data,
                                    DrawResult draw_result) override {
     EXPECT_EQ(2u, frame_data->render_passes.size());
     RenderPass* root_pass = frame_data->render_passes.back().get();
     EXPECT_EQ(3u, root_pass->quad_list.size());
@@ skipping 78 matching lines @@
     content_layer->SetBounds(layer_size);
     content_child_layer_->SetBounds(layer_size);
     content_child_layer_->SetPosition(gfx::PointF(50.f, 0.f));
 
     gfx::Size mask_size(100, 100);
     mask_layer->SetBounds(mask_size);
     mask_layer->SetIsMask(true);
 
     layer_tree_host()->SetRootLayer(root);
     LayerTreeTest::SetupTree();
+    client_.set_bounds(root->bounds());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                    LayerTreeHostImpl::FrameData* frame_data,
                                    DrawResult draw_result) override {
     EXPECT_EQ(2u, frame_data->render_passes.size());
     RenderPass* root_pass = frame_data->render_passes.back().get();
     EXPECT_EQ(3u, root_pass->quad_list.size());
@@ skipping 222 matching lines @@
     EndTest();
   }
 
   void AfterTest() override {}
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestPaintedDeviceScaleFactor);
 
 }  // namespace
 }  // namespace cc