cc: Reland Move data to LayerTree from LayerTreeHost.

cc/trees/layer_tree_host_unittest_context.cc

 // Copyright 2012 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 <stddef.h>
 #include <stdint.h>
 
 #include "base/memory/ptr_util.h"
 #include "cc/layers/heads_up_display_layer.h"
 #include "cc/layers/layer_impl.h"
@@ skipping 212 matching lines @@
 
     recovered_context_ = false;
     if (NextTestCase())
       InvalidateAndSetNeedsCommit();
     else
       EndTest();
   }
 
   virtual void InvalidateAndSetNeedsCommit() {
     // Cause damage so we try to draw.
-    layer_tree_host()->root_layer()->SetNeedsDisplay();
+    layer_tree()->root_layer()->SetNeedsDisplay();
     layer_tree_host()->SetNeedsCommit();
   }
 
   bool NextTestCase() {
     static const TestCase kTests[] = {
         // Losing the context and failing to recreate it (or losing it again
         // immediately) a small number of times should succeed.
         {
          1,      // times_to_lose_during_commit
          0,      // times_to_lose_during_draw
@@ skipping 383 matching lines @@
     SkPaint paint;
     paint.setColor(SkColorSetARGB(100, 80, 200, 200));
     client_.add_draw_rect(gfx::Rect(5, 5), paint);
 
     layer_ = FakePictureLayer::Create(&client_);
     layer_->SetBounds(gfx::Size(10, 10));
     layer_->SetIsDrawable(true);
 
     root_->AddChild(layer_);
 
-    layer_tree_host()->SetRootLayer(root_);
+    layer_tree()->SetRootLayer(root_);
     LayerTreeHostContextTest::SetupTree();
     client_.set_bounds(root_->bounds());
   }
 
   void InvalidateAndSetNeedsCommit() override {
     // Invalidate the render surface so we don't try to use a cached copy of the
     // surface.  We want to make sure to test the drawing paths for drawing to
     // a child surface.
     layer_->SetNeedsDisplay();
     LayerTreeHostContextTestLostContextSucceeds::InvalidateAndSetNeedsCommit();
@@ skipping 56 matching lines @@
   void SetupTree() override {
     // Paint non-solid color.
     SkPaint paint;
     paint.setColor(SkColorSetARGB(100, 80, 200, 200));
     client_.add_draw_rect(gfx::Rect(5, 5), paint);
 
     scoped_refptr<FakePictureLayer> picture_layer =
         FakePictureLayer::Create(&client_);
     picture_layer->SetBounds(gfx::Size(10, 20));
     client_.set_bounds(picture_layer->bounds());
-    layer_tree_host()->SetRootLayer(picture_layer);
+    layer_tree()->SetRootLayer(picture_layer);
 
     LayerTreeHostContextTest::SetupTree();
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void PostEvictTextures() {
     if (HasImplThread()) {
       ImplThreadTaskRunner()->PostTask(
           FROM_HERE,
@@ skipping 87 matching lines @@
       : LayerTreeHostContextTest(), num_commits_(0) {}
 
   void SetupTree() override {
     root_ = FakePictureLayer::Create(&client_);
     child_ = FakePictureLayer::Create(&client_);
     grandchild_ = FakePictureLayer::Create(&client_);
 
     root_->AddChild(child_);
     child_->AddChild(grandchild_);
 
-    layer_tree_host()->SetRootLayer(root_);
+    layer_tree()->SetRootLayer(root_);
     LayerTreeHostContextTest::SetupTree();
     client_.set_bounds(root_->bounds());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     LayerTreeHostContextTest::DidActivateTreeOnThread(host_impl);
 
     FakePictureLayerImpl* root_picture = NULL;
@@ skipping 173 matching lines @@
     debug_state.show_property_changed_rects = true;
     layer_tree_host()->SetDebugState(debug_state);
 
     scoped_refptr<PaintedScrollbarLayer> scrollbar =
         PaintedScrollbarLayer::Create(
             std::unique_ptr<Scrollbar>(new FakeScrollbar), layer->id());
     scrollbar->SetBounds(gfx::Size(10, 10));
     scrollbar->SetIsDrawable(true);
     root->AddChild(scrollbar);
 
-    layer_tree_host()->SetRootLayer(root);
+    layer_tree()->SetRootLayer(root);
     LayerTreeHostContextTest::SetupTree();
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     LayerTreeHostContextTest::CommitCompleteOnThread(host_impl);
 
     if (host_impl->active_tree()->source_frame_number() == 3) {
       // On the third commit we're recovering from context loss. Hardware
@@ skipping 19 matching lines @@
     // This will get called twice:
     // First when we create the initial output surface...
     if (layer_tree_host()->source_frame_number() > 0) {
       // ... and then again after we forced the context to be lost.
       lost_context_ = true;
     }
     LayerTreeHostContextTest::RequestNewOutputSurface();
   }
 
   void DidCommitAndDrawFrame() override {
-    ASSERT_TRUE(layer_tree_host()->hud_layer());
+    ASSERT_TRUE(layer_tree()->hud_layer());
     // End the test once we know the 3nd frame drew.
     if (layer_tree_host()->source_frame_number() < 5) {
-      layer_tree_host()->root_layer()->SetNeedsDisplay();
+      layer_tree()->root_layer()->SetNeedsDisplay();
       layer_tree_host()->SetNeedsCommit();
     } else {
       EndTest();
     }
   }
 
   void AfterTest() override { EXPECT_TRUE(lost_context_); }
 
  private:
   FakeContentLayerClient client_;
@@ skipping 22 matching lines @@
     scoped_refptr<Layer> root = Layer::Create();
     root->SetBounds(gfx::Size(10, 10));
     root->SetIsDrawable(true);
 
     scoped_refptr<PictureLayer> picture = PictureLayer::Create(&client_);
     picture->SetBounds(gfx::Size(10, 10));
     client_.set_bounds(picture->bounds());
     picture->SetIsDrawable(true);
     root->AddChild(picture);
 
-    layer_tree_host()->SetRootLayer(root);
+    layer_tree()->SetRootLayer(root);
     LayerTreeHostContextTest::SetupTree();
   }
 
   void BeginTest() override {
     times_to_lose_during_commit_ = 1;
     PostSetNeedsCommitToMainThread();
   }
 
   void AfterTest() override {}
 
   void DidInitializeOutputSurface() override { EndTest(); }
 
  private:
   FakeContentLayerClient client_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostContextTestImplSidePainting);
 
 class ScrollbarLayerLostContext : public LayerTreeHostContextTest {
  public:
   ScrollbarLayerLostContext() : commits_(0) {}
 
   void BeginTest() override {
     scoped_refptr<Layer> scroll_layer = Layer::Create();
     scrollbar_layer_ =
         FakePaintedScrollbarLayer::Create(false, true, scroll_layer->id());
     scrollbar_layer_->SetBounds(gfx::Size(10, 100));
-    layer_tree_host()->root_layer()->AddChild(scrollbar_layer_);
-    layer_tree_host()->root_layer()->AddChild(scroll_layer);
+    layer_tree()->root_layer()->AddChild(scrollbar_layer_);
+    layer_tree()->root_layer()->AddChild(scroll_layer);
     PostSetNeedsCommitToMainThread();
   }
 
   void AfterTest() override {}
 
   void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
     LayerTreeHostContextTest::CommitCompleteOnThread(impl);
 
     ++commits_;
     switch (commits_) {
@@ skipping 437 matching lines @@
   void AfterTest() override {}
 
   bool deferred_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostContextTestLoseAfterSendingBeginMainFrame);
 
 }  // namespace
 }  // namespace cc