Revert of cc: Remove use of PassAs() and constructor-casting with scoped_ptr.

cc/layers/delegated_renderer_layer_impl_unittest.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/layers/delegated_renderer_layer_impl.h"
 
 #include "cc/base/scoped_ptr_vector.h"
 #include "cc/layers/solid_color_layer_impl.h"
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/solid_color_draw_quad.h"
@@ skipping 22 matching lines @@
 class DelegatedRendererLayerImplTest : public testing::Test {
  public:
   DelegatedRendererLayerImplTest()
       : proxy_(),
         always_impl_thread_and_main_thread_blocked_(&proxy_) {
     LayerTreeSettings settings;
     settings.minimum_occlusion_tracking_size = gfx::Size();
 
     host_impl_.reset(
         new FakeLayerTreeHostImpl(settings, &proxy_, &shared_bitmap_manager_));
-    host_impl_->InitializeRenderer(FakeOutputSurface::Create3d());
+    host_impl_->InitializeRenderer(
+        FakeOutputSurface::Create3d().PassAs<OutputSurface>());
     host_impl_->SetViewportSize(gfx::Size(10, 10));
   }
 
  protected:
   FakeProxy proxy_;
   DebugScopedSetImplThreadAndMainThreadBlocked
       always_impl_thread_and_main_thread_blocked_;
   TestSharedBitmapManager shared_bitmap_manager_;
   scoped_ptr<LayerTreeHostImpl> host_impl_;
 };
 
 class DelegatedRendererLayerImplTestSimple
     : public DelegatedRendererLayerImplTest {
  public:
   DelegatedRendererLayerImplTestSimple()
       : DelegatedRendererLayerImplTest() {
-    scoped_ptr<LayerImpl> root_layer =
-        SolidColorLayerImpl::Create(host_impl_->active_tree(), 1);
-    scoped_ptr<LayerImpl> layer_before =
-        SolidColorLayerImpl::Create(host_impl_->active_tree(), 2);
-    scoped_ptr<LayerImpl> layer_after =
-        SolidColorLayerImpl::Create(host_impl_->active_tree(), 3);
+    scoped_ptr<LayerImpl> root_layer = SolidColorLayerImpl::Create(
+        host_impl_->active_tree(), 1).PassAs<LayerImpl>();
+    scoped_ptr<LayerImpl> layer_before = SolidColorLayerImpl::Create(
+        host_impl_->active_tree(), 2).PassAs<LayerImpl>();
+    scoped_ptr<LayerImpl> layer_after = SolidColorLayerImpl::Create(
+        host_impl_->active_tree(), 3).PassAs<LayerImpl>();
     scoped_ptr<FakeDelegatedRendererLayerImpl> delegated_renderer_layer =
         FakeDelegatedRendererLayerImpl::Create(host_impl_->active_tree(), 4);
 
     host_impl_->SetViewportSize(gfx::Size(100, 100));
     root_layer->SetBounds(gfx::Size(100, 100));
 
     layer_before->SetPosition(gfx::Point(20, 20));
     layer_before->SetBounds(gfx::Size(14, 14));
     layer_before->SetContentBounds(gfx::Size(14, 14));
     layer_before->SetDrawsContent(true);
@@ skipping 36 matching lines @@
     // The RenderPasses should be taken by the layer.
     EXPECT_EQ(0u, delegated_render_passes.size());
 
     root_layer_ = root_layer.get();
     layer_before_ = layer_before.get();
     layer_after_ = layer_after.get();
     delegated_renderer_layer_ = delegated_renderer_layer.get();
 
     // Force the delegated RenderPasses to come before the RenderPass from
     // layer_after.
-    layer_after->AddChild(delegated_renderer_layer.Pass());
+    layer_after->AddChild(delegated_renderer_layer.PassAs<LayerImpl>());
     root_layer->AddChild(layer_after.Pass());
 
     // Get the RenderPass generated by layer_before to come before the delegated
     // RenderPasses.
     root_layer->AddChild(layer_before.Pass());
     host_impl_->active_tree()->SetRootLayer(root_layer.Pass());
   }
 
  protected:
   LayerImpl* root_layer_;
@@ skipping 492 matching lines @@
 
     delegated_renderer_layer->SetFrameDataForRenderPasses(
         delegated_device_scale_factor_, &delegated_render_passes);
 
     // The RenderPasses should be taken by the layer.
     EXPECT_EQ(0u, delegated_render_passes.size());
 
     root_layer_ = root_layer.get();
     delegated_renderer_layer_ = delegated_renderer_layer.get();
 
-    root_layer->AddChild(delegated_renderer_layer.Pass());
+    root_layer->AddChild(delegated_renderer_layer.PassAs<LayerImpl>());
     host_impl_->active_tree()->SetRootLayer(root_layer.Pass());
   }
 
   void VerifyRenderPasses(
       const LayerTreeHostImpl::FrameData& frame,
       size_t num_render_passes,
       const SharedQuadState** root_delegated_shared_quad_state,
       const SharedQuadState** contrib_delegated_shared_quad_state) {
     ASSERT_EQ(num_render_passes, frame.render_passes.size());
     // The contributing render pass in the DelegatedRendererLayer.
@@ skipping 422 matching lines @@
       gfx::Rect clip_rect(21, 27, 23, 21);
 
       clip_layer->SetPosition(clip_rect.origin());
       clip_layer->SetBounds(clip_rect.size());
       clip_layer->SetContentBounds(clip_rect.size());
       clip_layer->SetMasksToBounds(true);
 
       origin_layer->SetPosition(
           gfx::PointAtOffsetFromOrigin(-clip_rect.OffsetFromOrigin()));
 
-      origin_layer->AddChild(delegated_renderer_layer.Pass());
+      origin_layer->AddChild(delegated_renderer_layer.PassAs<LayerImpl>());
       clip_layer->AddChild(origin_layer.Pass());
       root_layer->AddChild(clip_layer.Pass());
     } else {
-      root_layer->AddChild(delegated_renderer_layer.Pass());
+      root_layer->AddChild(delegated_renderer_layer.PassAs<LayerImpl>());
     }
 
     host_impl_->active_tree()->SetRootLayer(root_layer.Pass());
   }
 
  protected:
   LayerImpl* root_layer_;
   DelegatedRendererLayerImpl* delegated_renderer_layer_;
   bool root_delegated_render_pass_is_clipped_;
   bool clip_delegated_renderer_layer_;
@@ skipping 229 matching lines @@
   EXPECT_EQ(gfx::Rect(5, 5, 40, 40).ToString(),
             root_delegated_shared_quad_state->clip_rect.ToString());
   // Quads came with a clip rect.
   EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
 
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(DelegatedRendererLayerImplTest, InvalidRenderPassDrawQuad) {
-  scoped_ptr<LayerImpl> root_layer =
-      LayerImpl::Create(host_impl_->active_tree(), 1);
+  scoped_ptr<LayerImpl> root_layer = LayerImpl::Create(
+      host_impl_->active_tree(), 1).PassAs<LayerImpl>();
   scoped_ptr<FakeDelegatedRendererLayerImpl> delegated_renderer_layer =
       FakeDelegatedRendererLayerImpl::Create(host_impl_->active_tree(), 4);
 
   host_impl_->SetViewportSize(gfx::Size(100, 100));
 
   delegated_renderer_layer->SetPosition(gfx::Point(3, 3));
   delegated_renderer_layer->SetBounds(gfx::Size(10, 10));
   delegated_renderer_layer->SetContentBounds(gfx::Size(10, 10));
   delegated_renderer_layer->SetDrawsContent(true);
 
@@ skipping 13 matching lines @@
 
   // But a render pass quad refers to it.
   AddRenderPassQuad(pass1, missing_pass.get());
 
   delegated_renderer_layer->SetFrameDataForRenderPasses(
       1.f, &delegated_render_passes);
 
   // The RenderPasses should be taken by the layer.
   EXPECT_EQ(0u, delegated_render_passes.size());
 
-  root_layer->AddChild(delegated_renderer_layer.Pass());
+  root_layer->AddChild(delegated_renderer_layer.PassAs<LayerImpl>());
   host_impl_->active_tree()->SetRootLayer(root_layer.Pass());
 
   LayerTreeHostImpl::FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
   // The DelegatedRendererLayerImpl should drop the bad RenderPassDrawQuad.
   ASSERT_EQ(1u, frame.render_passes.size());
   ASSERT_EQ(1u, frame.render_passes[0]->quad_list.size());
   EXPECT_EQ(DrawQuad::SOLID_COLOR,
             frame.render_passes[0]->quad_list.front()->material);
@@ skipping 187 matching lines @@
   scoped_ptr<DelegatedRendererLayerImpl> other_layer =
       DelegatedRendererLayerImpl::Create(host_impl_->active_tree(), 6);
 
   delegated_renderer_layer_impl->PushPropertiesTo(other_layer.get());
 
   EXPECT_EQ(0.5f, other_layer->inverse_device_scale_factor());
 }
 
 }  // namespace
 }  // namespace cc