cc: Chromify the LayerTreeHostImpl class.

cc/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 "cc/layer_tree_host.h"
 
 #include "base/basictypes.h"
 #include "cc/content_layer.h"
 #include "cc/heads_up_display_layer.h"
 #include "cc/io_surface_layer.h"
@@ skipping 130 matching lines @@
 
     if (!offscreen_contexts_compositor_thread_ ||
         offscreen_contexts_compositor_thread_->DestroyedOnMainThread()) {
       offscreen_contexts_compositor_thread_ = new FakeContextProvider(
           base::Bind(&LayerTreeHostContextTest::CreateOffscreenContext3d,
                      base::Unretained(this)));
     }
     return offscreen_contexts_compositor_thread_;
   }
 
-  virtual bool prepareToDrawOnThread(
-      LayerTreeHostImpl*, LayerTreeHostImpl::FrameData&, bool result)
+  virtual bool prepareToDrawOnThread(LayerTreeHostImpl* host_impl,
+                                     LayerTreeHostImpl::FrameData* frame,
+                                     bool result)
       OVERRIDE {
     EXPECT_TRUE(result);
     if (!times_to_lose_during_draw_)
       return result;
 
     --times_to_lose_during_draw_;
     context3d_->set_times_make_current_succeeds(0);
 
     times_to_fail_create_ = times_to_fail_recreate_;
     times_to_fail_recreate_ = 0;
@@ skipping 253 matching lines @@
   virtual 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.
     content_->SetNeedsDisplay();
     LayerTreeHostContextTestLostContextSucceeds::InvalidateAndSetNeedsCommit();
   }
 
   virtual void drawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
     FakeContentLayerImpl* content_impl = static_cast<FakeContentLayerImpl*>(
-        host_impl->rootLayer()->children()[0]);
+        host_impl->active_tree()->root_layer()->children()[0]);
     // Even though the context was lost, we should have a resource. The
     // TestWebGraphicsContext3D ensures that this resource is created with
     // the active context.
     EXPECT_TRUE(content_impl->HaveResourceForTileAt(0, 0));
 
     cc::ContextProvider* contexts =
-        host_impl->resourceProvider()->offscreen_context_provider();
+        host_impl->resource_provider()->offscreen_context_provider();
     if (use_surface_) {
       EXPECT_TRUE(contexts->Context3d());
       // TODO(danakj): Make a fake GrContext.
       //EXPECT_TRUE(contexts->GrContext());
     } else {
       EXPECT_FALSE(contexts);
     }
   }
 
   virtual void afterTest() OVERRIDE {
@@ skipping 68 matching lines @@
     LayerTreeHostContextTest::setupTree();
   }
 
   virtual void beginTest() OVERRIDE {
     times_to_fail_create_offscreen_ = 1;
     postSetNeedsCommitToMainThread();
   }
 
   virtual void drawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
     cc::ContextProvider* contexts =
-        host_impl->resourceProvider()->offscreen_context_provider();
+        host_impl->resource_provider()->offscreen_context_provider();
     EXPECT_FALSE(contexts);
     endTest();
   }
 
   virtual void afterTest() OVERRIDE {}
 
  protected:
   FakeContentLayerClient client_;
   scoped_refptr<Layer> root_;
   scoped_refptr<ContentLayer> content_;
@@ skipping 18 matching lines @@
     EXPECT_FALSE(succeeded);
     endTest();
   }
 
   virtual void commitCompleteOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
     LayerTreeHostContextTest::commitCompleteOnThread(host_impl);
 
     ++num_commits_;
     if (num_commits_ == 1) {
       // When the context is ok, we should have these things.
-      EXPECT_TRUE(host_impl->outputSurface());
+      EXPECT_TRUE(host_impl->output_surface());
       EXPECT_TRUE(host_impl->renderer());
-      EXPECT_TRUE(host_impl->resourceProvider());
+      EXPECT_TRUE(host_impl->resource_provider());
       return;
     }
 
     // When context recreation fails we shouldn't be left with any of them.
-    EXPECT_FALSE(host_impl->outputSurface());
+    EXPECT_FALSE(host_impl->output_surface());
     EXPECT_FALSE(host_impl->renderer());
-    EXPECT_FALSE(host_impl->resourceProvider());
+    EXPECT_FALSE(host_impl->resource_provider());
   }
 
   virtual void afterTest() OVERRIDE {}
 
  private:
   int num_commits_;
 };
 
-TEST_F(LayerTreeHostContextTestLostContextFails, FailReinitialize100_SingleThread) {
+TEST_F(LayerTreeHostContextTestLostContextFails,
+       FailReinitialize100_SingleThread) {
   times_to_fail_reinitialize_ = 100;
   times_to_fail_recreate_ = 0;
   times_to_lose_on_recreate_ = 0;
   runTest(false);
 }
 
-TEST_F(LayerTreeHostContextTestLostContextFails, FailReinitialize100_MultiThread) {
+TEST_F(LayerTreeHostContextTestLostContextFails,
+       FailReinitialize100_MultiThread) {
   times_to_fail_reinitialize_ = 100;
   times_to_fail_recreate_ = 0;
   times_to_lose_on_recreate_ = 0;
   runTest(true);
 }
 
-TEST_F(LayerTreeHostContextTestLostContextFails, FailRecreate100_SingleThread) {
+TEST_F(LayerTreeHostContextTestLostContextFails,
+       FailRecreate100_SingleThread) {
   times_to_fail_reinitialize_ = 0;
   times_to_fail_recreate_ = 100;
   times_to_lose_on_recreate_ = 0;
   runTest(false);
 }
 
-TEST_F(LayerTreeHostContextTestLostContextFails, FailRecreate100_MultiThread) {
+TEST_F(LayerTreeHostContextTestLostContextFails,
+       FailRecreate100_MultiThread) {
   times_to_fail_reinitialize_ = 0;
   times_to_fail_recreate_ = 100;
   times_to_lose_on_recreate_ = 0;
   runTest(true);
 }
 
-TEST_F(LayerTreeHostContextTestLostContextFails, LoseOnRecreate100_SingleThread) {
+TEST_F(LayerTreeHostContextTestLostContextFails,
+       LoseOnRecreate100_SingleThread) {
   times_to_fail_reinitialize_ = 0;
   times_to_fail_recreate_ = 0;
   times_to_lose_on_recreate_ = 100;
   runTest(false);
 }
 
-TEST_F(LayerTreeHostContextTestLostContextFails, LoseOnRecreate100_MultiThread) {
+TEST_F(LayerTreeHostContextTestLostContextFails,
+       LoseOnRecreate100_MultiThread) {
   times_to_fail_reinitialize_ = 0;
   times_to_fail_recreate_ = 0;
   times_to_lose_on_recreate_ = 100;
   runTest(true);
 }
 
 class LayerTreeHostContextTestFinishAllRenderingAfterLoss :
       public LayerTreeHostContextTest {
  public:
   virtual void beginTest() OVERRIDE {
@@ skipping 192 matching lines @@
   }
 
   virtual void beginTest() OVERRIDE {
     postSetNeedsCommitToMainThread();
   }
 
   virtual void commitCompleteOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
     LayerTreeHostContextTest::commitCompleteOnThread(host_impl);
 
     FakeContentLayerImpl* root = static_cast<FakeContentLayerImpl*>(
-        host_impl->rootLayer());
+        host_impl->active_tree()->root_layer());
     FakeContentLayerImpl* child = static_cast<FakeContentLayerImpl*>(
         root->children()[0]);
     FakeContentLayerImpl* grandchild = static_cast<FakeContentLayerImpl*>(
         child->children()[0]);
 
     ++num_commits_;
     switch (num_commits_) {
       case 1:
         EXPECT_EQ(0u, root->lost_output_surface_count());
         EXPECT_EQ(0u, child->lost_output_surface_count());
@@ skipping 137 matching lines @@
     LayerTreeHostContextTest::setupTree();
   }
 
   virtual void beginTest() OVERRIDE {
     postSetNeedsCommitToMainThread();
   }
 
   virtual void commitCompleteOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
     LayerTreeHostContextTest::commitCompleteOnThread(host_impl);
 
-    ResourceProvider* resource_provider = host_impl->resourceProvider();
+    ResourceProvider* resource_provider = host_impl->resource_provider();
 
-    if (host_impl->activeTree()->source_frame_number() == 0) {
+    if (host_impl->active_tree()->source_frame_number() == 0) {
       // Set up impl resources on the first commit.
 
       scoped_ptr<TestRenderPass> pass_for_quad = TestRenderPass::Create();
       pass_for_quad->SetNew(
           // AppendOneOfEveryQuadType() makes a RenderPass quad with this id.
           RenderPass::Id(1, 1),
           gfx::Rect(0, 0, 10, 10),
           gfx::Rect(0, 0, 10, 10),
           gfx::Transform());
 
       scoped_ptr<TestRenderPass> pass = TestRenderPass::Create();
       pass->SetNew(
           RenderPass::Id(2, 1),
           gfx::Rect(0, 0, 10, 10),
           gfx::Rect(0, 0, 10, 10),
           gfx::Transform());
       pass->AppendOneOfEveryQuadType(resource_provider, RenderPass::Id(2, 1));
 
       ScopedPtrVector<RenderPass> pass_list;
       pass_list.push_back(pass_for_quad.PassAs<RenderPass>());
       pass_list.push_back(pass.PassAs<RenderPass>());
 
       // First child is the delegated layer.
       FakeDelegatedRendererLayerImpl* delegated_impl =
           static_cast<FakeDelegatedRendererLayerImpl*>(
-              host_impl->rootLayer()->children()[0]);
+              host_impl->active_tree()->root_layer()->children()[0]);
       delegated_impl->SetFrameDataForRenderPasses(&pass_list);
       EXPECT_TRUE(pass_list.empty());
 
       color_video_frame_ = VideoFrame::CreateColorFrame(
           gfx::Size(4, 4), 0x80, 0x80, 0x80, base::TimeDelta());
       hw_video_frame_ = VideoFrame::WrapNativeTexture(
           resource_provider->GraphicsContext3D()->createTexture(),
           GL_TEXTURE_2D,
           gfx::Size(4, 4), gfx::Rect(0, 0, 4, 4), gfx::Size(4, 4),
           base::TimeDelta(),
           VideoFrame::ReadPixelsCB(),
           base::Closure());
       scaled_hw_video_frame_ = VideoFrame::WrapNativeTexture(
           resource_provider->GraphicsContext3D()->createTexture(),
           GL_TEXTURE_2D,
           gfx::Size(4, 4), gfx::Rect(0, 0, 3, 2), gfx::Size(4, 4),
           base::TimeDelta(),
           VideoFrame::ReadPixelsCB(),
           base::Closure());
 
       color_frame_provider_.set_frame(color_video_frame_);
       hw_frame_provider_.set_frame(hw_video_frame_);
       scaled_hw_frame_provider_.set_frame(scaled_hw_video_frame_);
       return;
     }
 
-    if (host_impl->activeTree()->source_frame_number() == 3) {
+    if (host_impl->active_tree()->source_frame_number() == 3) {
       // On the third commit we're recovering from context loss. Hardware
       // video frames should not be reused by the VideoFrameProvider, but
       // software frames can be.
       hw_frame_provider_.set_frame(NULL);
       scaled_hw_frame_provider_.set_frame(NULL);
     }
   }
 
   virtual bool prepareToDrawOnThread(
       LayerTreeHostImpl* host_impl,
-      LayerTreeHostImpl::FrameData& frame,
+      LayerTreeHostImpl::FrameData* frame,
       bool result) OVERRIDE {
-    if (host_impl->activeTree()->source_frame_number() == 2) {
+    if (host_impl->active_tree()->source_frame_number() == 2) {
       // Lose the context during draw on the second commit. This will cause
       // a third commit to recover.
       if (context3d_)
         context3d_->set_times_bind_texture_succeeds(4);
     }
     return true;
   }
 
   virtual void didCommitAndDrawFrame() OVERRIDE {
     ASSERT_TRUE(m_layerTreeHost->hud_layer());
@@ skipping 155 matching lines @@
 
  private:
   int commits_;
   scoped_refptr<FakeScrollbarLayer> scrollbar_layer_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(ScrollbarLayerLostContext)
 
 }  // namespace
 }  // namespace cc