Revert of cc: Remove use of PassAs() and constructor-casting with scoped_ptr. (patchset #6 id:120001 of https://codereview.chromium.org/609663003/)

Reason for revert:
scoped_ptr nullptr support needs to be reverted

Original issue's description:
> cc: Remove use of PassAs() and constructor-casting with scoped_ptr.
>
> Say you have class A and subclass B.
>
> Previously it was required to PassAs() a scoped_ptr<B> into a
> scoped_ptr<A>. This is no longer needed, so just use Pass(). For newly
> created scoped_ptrs, you can just use make_scoped_ptr always now.
>
> And when you want to return or assign an empty scoped_ptr(), you can
> now use nullptr directly.
>
> Also adds PRESUBMIT checks for:
> - return scoped<T>(foo). This should be return make_scoped_ptr(foo).
> - bar = scoped<T>(foo). This should be return bar = make_scoped_ptr(foo).
> - return scoped<T>(). This should be return nullptr.
> - bar = scoped<T>(). This should be return bar = nullptr.
>
> This also replaces p.reset() with p = nullptr; But it does not add a
> PRESUBMIT check for that because there are things other than scoped_ptr
> with a reset() function.
>
> R=enne@chromium.org
>
> Committed: https://crrev.com/7bb3dbede19d87f0338797756ffd738adc6bca08
> Cr-Commit-Position: refs/heads/master@{#297096}

TBR=enne@chromium.org,jamesr@chromium.org,vmpstr@chromium.org,danakj@chromium.org
NOTREECHECKS=true
NOTRY=true

Review URL: https://codereview.chromium.org/608503005

Cr-Commit-Position: refs/heads/master@{#297106}

41 files changed, 129 insertions, 101 deletions

diff --git a/cc/layers/content_layer.cc b/cc/layers/content_layer.cc
index 3bd2379..8986686 100644
--- a/cc/layers/content_layer.cc
+++ b/cc/layers/content_layer.cc
@@ -99,7 +99,8 @@ LayerUpdater* ContentLayer::Updater() const {
 void ContentLayer::CreateUpdaterIfNeeded() {
   if (updater_.get())
     return;
-  scoped_ptr<LayerPainter> painter = ContentLayerPainter::Create(client_);
+  scoped_ptr<LayerPainter> painter =
+      ContentLayerPainter::Create(client_).PassAs<LayerPainter>();
   if (layer_tree_host()->settings().per_tile_painting_enabled) {
     updater_ = BitmapSkPictureContentLayerUpdater::Create(
         painter.Pass(),
diff --git a/cc/layers/delegated_renderer_layer.cc b/cc/layers/delegated_renderer_layer.cc
index bf90305..6ccdbec 100644
--- a/cc/layers/delegated_renderer_layer.cc
+++ b/cc/layers/delegated_renderer_layer.cc
@@ -33,7 +33,8 @@ DelegatedRendererLayer::~DelegatedRendererLayer() {
 
 scoped_ptr<LayerImpl> DelegatedRendererLayer::CreateLayerImpl(
     LayerTreeImpl* tree_impl) {
-  return DelegatedRendererLayerImpl::Create(tree_impl, layer_id_);
+  return DelegatedRendererLayerImpl::Create(
+      tree_impl, layer_id_).PassAs<LayerImpl>();
 }
 
 void DelegatedRendererLayer::SetLayerTreeHost(LayerTreeHost* host) {
diff --git a/cc/layers/delegated_renderer_layer_impl.cc b/cc/layers/delegated_renderer_layer_impl.cc
index c8af1fa..bd19086 100644
--- a/cc/layers/delegated_renderer_layer_impl.cc
+++ b/cc/layers/delegated_renderer_layer_impl.cc
@@ -183,7 +183,8 @@ void DelegatedRendererLayerImpl::ClearRenderPasses() {
 
 scoped_ptr<LayerImpl> DelegatedRendererLayerImpl::CreateLayerImpl(
     LayerTreeImpl* tree_impl) {
-  return DelegatedRendererLayerImpl::Create(tree_impl, id());
+  return DelegatedRendererLayerImpl::Create(
+      tree_impl, id()).PassAs<LayerImpl>();
 }
 
 void DelegatedRendererLayerImpl::ReleaseResources() {
diff --git a/cc/layers/delegated_renderer_layer_impl_unittest.cc b/cc/layers/delegated_renderer_layer_impl_unittest.cc
index 832a483..d219f5a 100644
--- a/cc/layers/delegated_renderer_layer_impl_unittest.cc
+++ b/cc/layers/delegated_renderer_layer_impl_unittest.cc
@@ -40,7 +40,8 @@ class DelegatedRendererLayerImplTest : public testing::Test {
 
     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));
   }
 
@@ -57,12 +58,12 @@ class DelegatedRendererLayerImplTestSimple
  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);
 
@@ -119,7 +120,7 @@ class DelegatedRendererLayerImplTestSimple
 
     // 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
@@ -632,7 +633,7 @@ class DelegatedRendererLayerImplTestTransform
     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());
   }
 
@@ -1075,11 +1076,11 @@ class DelegatedRendererLayerImplTestClip
       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());
@@ -1329,8 +1330,8 @@ TEST_F(DelegatedRendererLayerImplTestClip, QuadsClipped_LayerClipped_Surface) {
 }
 
 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);
 
@@ -1364,7 +1365,7 @@ TEST_F(DelegatedRendererLayerImplTest, InvalidRenderPassDrawQuad) {
   // 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;
diff --git a/cc/layers/heads_up_display_layer.cc b/cc/layers/heads_up_display_layer.cc
index 5c91249..6adf8d0 100644
--- a/cc/layers/heads_up_display_layer.cc
+++ b/cc/layers/heads_up_display_layer.cc
@@ -56,7 +56,8 @@ bool HeadsUpDisplayLayer::HasDrawableContent() const {
 
 scoped_ptr<LayerImpl> HeadsUpDisplayLayer::CreateLayerImpl(
     LayerTreeImpl* tree_impl) {
-  return HeadsUpDisplayLayerImpl::Create(tree_impl, layer_id_);
+  return HeadsUpDisplayLayerImpl::Create(tree_impl, layer_id_).
+      PassAs<LayerImpl>();
 }
 
 }  // namespace cc
diff --git a/cc/layers/heads_up_display_layer_impl.cc b/cc/layers/heads_up_display_layer_impl.cc
index ab9e8a4..51c0ed2 100644
--- a/cc/layers/heads_up_display_layer_impl.cc
+++ b/cc/layers/heads_up_display_layer_impl.cc
@@ -78,7 +78,7 @@ HeadsUpDisplayLayerImpl::~HeadsUpDisplayLayerImpl() {}
 
 scoped_ptr<LayerImpl> HeadsUpDisplayLayerImpl::CreateLayerImpl(
     LayerTreeImpl* tree_impl) {
-  return HeadsUpDisplayLayerImpl::Create(tree_impl, id());
+  return HeadsUpDisplayLayerImpl::Create(tree_impl, id()).PassAs<LayerImpl>();
 }
 
 void HeadsUpDisplayLayerImpl::AcquireResource(
diff --git a/cc/layers/heads_up_display_layer_impl_unittest.cc b/cc/layers/heads_up_display_layer_impl_unittest.cc
index 828a93a..2c057dd 100644
--- a/cc/layers/heads_up_display_layer_impl_unittest.cc
+++ b/cc/layers/heads_up_display_layer_impl_unittest.cc
@@ -36,7 +36,8 @@ TEST(HeadsUpDisplayLayerImplTest, ResourcelessSoftwareDrawAfterResourceLoss) {
   TestSharedBitmapManager shared_bitmap_manager;
   FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
   host_impl.CreatePendingTree();
-  host_impl.InitializeRenderer(FakeOutputSurface::Create3d());
+  host_impl.InitializeRenderer(
+      FakeOutputSurface::Create3d().PassAs<OutputSurface>());
   scoped_ptr<HeadsUpDisplayLayerImpl> layer =
     HeadsUpDisplayLayerImpl::Create(host_impl.pending_tree(), 1);
   layer->SetContentBounds(gfx::Size(100, 100));
diff --git a/cc/layers/io_surface_layer.cc b/cc/layers/io_surface_layer.cc
index 05d5fb9..0682aee 100644
--- a/cc/layers/io_surface_layer.cc
+++ b/cc/layers/io_surface_layer.cc
@@ -26,7 +26,7 @@ void IOSurfaceLayer::SetIOSurfaceProperties(uint32_t io_surface_id,
 
 scoped_ptr<LayerImpl> IOSurfaceLayer::CreateLayerImpl(
     LayerTreeImpl* tree_impl) {
-  return IOSurfaceLayerImpl::Create(tree_impl, layer_id_);
+  return IOSurfaceLayerImpl::Create(tree_impl, layer_id_).PassAs<LayerImpl>();
 }
 
 bool IOSurfaceLayer::HasDrawableContent() const {
diff --git a/cc/layers/io_surface_layer_impl.cc b/cc/layers/io_surface_layer_impl.cc
index 7cb86ce..e64c9e7 100644
--- a/cc/layers/io_surface_layer_impl.cc
+++ b/cc/layers/io_surface_layer_impl.cc
@@ -38,7 +38,7 @@ void IOSurfaceLayerImpl::DestroyResource() {
 
 scoped_ptr<LayerImpl> IOSurfaceLayerImpl::CreateLayerImpl(
     LayerTreeImpl* tree_impl) {
-  return IOSurfaceLayerImpl::Create(tree_impl, id());
+  return IOSurfaceLayerImpl::Create(tree_impl, id()).PassAs<LayerImpl>();
 }
 
 void IOSurfaceLayerImpl::PushPropertiesTo(LayerImpl* layer) {
diff --git a/cc/layers/layer.cc b/cc/layers/layer.cc
index 1326b79..1a22d92 100644
--- a/cc/layers/layer.cc
+++ b/cc/layers/layer.cc
@@ -620,7 +620,7 @@ void Layer::AddScrollChild(Layer* child) {
 void Layer::RemoveScrollChild(Layer* child) {
   scroll_children_->erase(child);
   if (scroll_children_->empty())
-    scroll_children_ = nullptr;
+    scroll_children_.reset();
   SetNeedsCommit();
 }
 
@@ -650,7 +650,7 @@ void Layer::AddClipChild(Layer* child) {
 void Layer::RemoveClipChild(Layer* child) {
   clip_children_->erase(child);
   if (clip_children_->empty())
-    clip_children_ = nullptr;
+    clip_children_.reset();
   SetNeedsCommit();
 }
 
@@ -1085,7 +1085,7 @@ void Layer::CreateRenderSurface() {
 }
 
 void Layer::ClearRenderSurface() {
-  draw_properties_.render_surface = nullptr;
+  draw_properties_.render_surface.reset();
 }
 
 void Layer::ClearRenderSurfaceLayerList() {
diff --git a/cc/layers/layer_impl.cc b/cc/layers/layer_impl.cc
index 224513c..29bdfe7 100644
--- a/cc/layers/layer_impl.cc
+++ b/cc/layers/layer_impl.cc
@@ -119,7 +119,7 @@ scoped_ptr<LayerImpl> LayerImpl::RemoveChild(LayerImpl* child) {
       return ret.Pass();
     }
   }
-  return nullptr;
+  return scoped_ptr<LayerImpl>();
 }
 
 void LayerImpl::SetParent(LayerImpl* parent) {
@@ -246,7 +246,7 @@ void LayerImpl::CreateRenderSurface() {
 }
 
 void LayerImpl::ClearRenderSurface() {
-  draw_properties_.render_surface = nullptr;
+  draw_properties_.render_surface.reset();
 }
 
 void LayerImpl::ClearRenderSurfaceLayerList() {
@@ -1324,7 +1324,7 @@ void LayerImpl::DidBecomeActive() {
 
   bool need_scrollbar_animation_controller = scrollable() && scrollbars_;
   if (!need_scrollbar_animation_controller) {
-    scrollbar_animation_controller_ = nullptr;
+    scrollbar_animation_controller_.reset();
     return;
   }
 
@@ -1358,7 +1358,7 @@ void LayerImpl::RemoveScrollbar(ScrollbarLayerImplBase* layer) {
 
   scrollbars_->erase(layer);
   if (scrollbars_->empty())
-    scrollbars_ = nullptr;
+    scrollbars_.reset();
 }
 
 bool LayerImpl::HasScrollbar(ScrollbarOrientation orientation) const {
diff --git a/cc/layers/layer_impl_unittest.cc b/cc/layers/layer_impl_unittest.cc
index b9366ac..c5cac8d 100644
--- a/cc/layers/layer_impl_unittest.cc
+++ b/cc/layers/layer_impl_unittest.cc
@@ -86,7 +86,8 @@ TEST(LayerImplTest, VerifyLayerChangesAreTrackedProperly) {
   FakeImplProxy proxy;
   TestSharedBitmapManager shared_bitmap_manager;
   FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
-  EXPECT_TRUE(host_impl.InitializeRenderer(FakeOutputSurface::Create3d()));
+  EXPECT_TRUE(host_impl.InitializeRenderer(
+      FakeOutputSurface::Create3d().PassAs<OutputSurface>()));
   scoped_ptr<LayerImpl> root_clip =
       LayerImpl::Create(host_impl.active_tree(), 1);
   scoped_ptr<LayerImpl> root_ptr =
@@ -246,7 +247,8 @@ TEST(LayerImplTest, VerifyNeedsUpdateDrawProperties) {
   FakeImplProxy proxy;
   TestSharedBitmapManager shared_bitmap_manager;
   FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
-  EXPECT_TRUE(host_impl.InitializeRenderer(FakeOutputSurface::Create3d()));
+  EXPECT_TRUE(host_impl.InitializeRenderer(
+      FakeOutputSurface::Create3d().PassAs<OutputSurface>()));
   host_impl.active_tree()->SetRootLayer(
       LayerImpl::Create(host_impl.active_tree(), 1));
   LayerImpl* root = host_impl.active_tree()->root_layer();
@@ -355,7 +357,8 @@ TEST(LayerImplTest, SafeOpaqueBackgroundColor) {
   FakeImplProxy proxy;
   TestSharedBitmapManager shared_bitmap_manager;
   FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
-  EXPECT_TRUE(host_impl.InitializeRenderer(FakeOutputSurface::Create3d()));
+  EXPECT_TRUE(host_impl.InitializeRenderer(
+      FakeOutputSurface::Create3d().PassAs<OutputSurface>()));
   scoped_ptr<LayerImpl> layer = LayerImpl::Create(host_impl.active_tree(), 1);
 
   for (int contents_opaque = 0; contents_opaque < 2; ++contents_opaque) {
diff --git a/cc/layers/layer_perftest.cc b/cc/layers/layer_perftest.cc
index 18b4355..5df2e8f 100644
--- a/cc/layers/layer_perftest.cc
+++ b/cc/layers/layer_perftest.cc
@@ -46,7 +46,7 @@ class LayerPerfTest : public testing::Test {
 
   virtual void TearDown() OVERRIDE {
     layer_tree_host_->SetRootLayer(NULL);
-    layer_tree_host_ = nullptr;
+    layer_tree_host_.reset();
   }
 
   FakeImplProxy proxy_;
diff --git a/cc/layers/layer_unittest.cc b/cc/layers/layer_unittest.cc
index 846951d..3950cf2 100644
--- a/cc/layers/layer_unittest.cc
+++ b/cc/layers/layer_unittest.cc
@@ -78,7 +78,7 @@ class LayerTest : public testing::Test {
     grand_child3_ = NULL;
 
     layer_tree_host_->SetRootLayer(NULL);
-    layer_tree_host_ = nullptr;
+    layer_tree_host_.reset();
   }
 
   void VerifyTestTreeInitialState() const {
@@ -1144,7 +1144,10 @@ static bool AddTestAnimation(Layer* layer) {
                                            0.7f,
                                            scoped_ptr<TimingFunction>()));
   scoped_ptr<Animation> animation =
-      Animation::Create(curve.Pass(), 0, 0, Animation::Opacity);
+      Animation::Create(curve.PassAs<AnimationCurve>(),
+                        0,
+                        0,
+                        Animation::Opacity);
 
   return layer->AddAnimation(animation.Pass());
 }
diff --git a/cc/layers/nine_patch_layer.cc b/cc/layers/nine_patch_layer.cc
index ad8f04d..e63b000 100644
--- a/cc/layers/nine_patch_layer.cc
+++ b/cc/layers/nine_patch_layer.cc
@@ -24,7 +24,7 @@ NinePatchLayer::~NinePatchLayer() {}
 
 scoped_ptr<LayerImpl> NinePatchLayer::CreateLayerImpl(
     LayerTreeImpl* tree_impl) {
-  return NinePatchLayerImpl::Create(tree_impl, id());
+  return NinePatchLayerImpl::Create(tree_impl, id()).PassAs<LayerImpl>();
 }
 
 void NinePatchLayer::SetBorder(const gfx::Rect& border) {
diff --git a/cc/layers/nine_patch_layer_impl.cc b/cc/layers/nine_patch_layer_impl.cc
index ba3f30c..c27205f 100644
--- a/cc/layers/nine_patch_layer_impl.cc
+++ b/cc/layers/nine_patch_layer_impl.cc
@@ -22,7 +22,7 @@ NinePatchLayerImpl::~NinePatchLayerImpl() {}
 
 scoped_ptr<LayerImpl> NinePatchLayerImpl::CreateLayerImpl(
     LayerTreeImpl* tree_impl) {
-  return NinePatchLayerImpl::Create(tree_impl, id());
+  return NinePatchLayerImpl::Create(tree_impl, id()).PassAs<LayerImpl>();
 }
 
 void NinePatchLayerImpl::PushPropertiesTo(LayerImpl* layer) {
diff --git a/cc/layers/painted_scrollbar_layer.cc b/cc/layers/painted_scrollbar_layer.cc
index 83c12e8..65fb78d 100644
--- a/cc/layers/painted_scrollbar_layer.cc
+++ b/cc/layers/painted_scrollbar_layer.cc
@@ -23,7 +23,7 @@ namespace cc {
 scoped_ptr<LayerImpl> PaintedScrollbarLayer::CreateLayerImpl(
     LayerTreeImpl* tree_impl) {
   return PaintedScrollbarLayerImpl::Create(
-      tree_impl, id(), scrollbar_->Orientation());
+      tree_impl, id(), scrollbar_->Orientation()).PassAs<LayerImpl>();
 }
 
 scoped_refptr<PaintedScrollbarLayer> PaintedScrollbarLayer::Create(
@@ -156,8 +156,8 @@ void PaintedScrollbarLayer::SetLayerTreeHost(LayerTreeHost* host) {
   // When the LTH is set to null or has changed, then this layer should remove
   // all of its associated resources.
   if (!host || host != layer_tree_host()) {
-    track_resource_ = nullptr;
-    thumb_resource_ = nullptr;
+    track_resource_.reset();
+    thumb_resource_.reset();
   }
 
   ContentsScalingLayer::SetLayerTreeHost(host);
@@ -214,8 +214,9 @@ bool PaintedScrollbarLayer::Update(ResourceUpdateQueue* queue,
 
   if (track_rect_.IsEmpty() || scaled_track_rect.IsEmpty()) {
     if (track_resource_) {
-      track_resource_ = nullptr;
-      thumb_resource_ = nullptr;
+      track_resource_.reset();
+      if (thumb_resource_)
+        thumb_resource_.reset();
       SetNeedsPushProperties();
       updated = true;
     }
@@ -223,7 +224,7 @@ bool PaintedScrollbarLayer::Update(ResourceUpdateQueue* queue,
   }
 
   if (!has_thumb_ && thumb_resource_) {
-    thumb_resource_ = nullptr;
+    thumb_resource_.reset();
     SetNeedsPushProperties();
   }
 
diff --git a/cc/layers/painted_scrollbar_layer_impl.cc b/cc/layers/painted_scrollbar_layer_impl.cc
index 16196dd..d48c49f 100644
--- a/cc/layers/painted_scrollbar_layer_impl.cc
+++ b/cc/layers/painted_scrollbar_layer_impl.cc
@@ -43,7 +43,8 @@ PaintedScrollbarLayerImpl::~PaintedScrollbarLayerImpl() {}
 
 scoped_ptr<LayerImpl> PaintedScrollbarLayerImpl::CreateLayerImpl(
     LayerTreeImpl* tree_impl) {
-  return PaintedScrollbarLayerImpl::Create(tree_impl, id(), orientation());
+  return PaintedScrollbarLayerImpl::Create(tree_impl, id(), orientation())
+      .PassAs<LayerImpl>();
 }
 
 void PaintedScrollbarLayerImpl::PushPropertiesTo(LayerImpl* layer) {
diff --git a/cc/layers/picture_image_layer.cc b/cc/layers/picture_image_layer.cc
index dba506e..98c0e9b 100644
--- a/cc/layers/picture_image_layer.cc
+++ b/cc/layers/picture_image_layer.cc
@@ -21,7 +21,7 @@ PictureImageLayer::~PictureImageLayer() {
 
 scoped_ptr<LayerImpl> PictureImageLayer::CreateLayerImpl(
     LayerTreeImpl* tree_impl) {
-  return PictureImageLayerImpl::Create(tree_impl, id());
+  return PictureImageLayerImpl::Create(tree_impl, id()).PassAs<LayerImpl>();
 }
 
 bool PictureImageLayer::HasDrawableContent() const {
diff --git a/cc/layers/picture_image_layer_impl.cc b/cc/layers/picture_image_layer_impl.cc
index a72ab01..247c46a 100644
--- a/cc/layers/picture_image_layer_impl.cc
+++ b/cc/layers/picture_image_layer_impl.cc
@@ -24,7 +24,7 @@ const char* PictureImageLayerImpl::LayerTypeAsString() const {
 
 scoped_ptr<LayerImpl> PictureImageLayerImpl::CreateLayerImpl(
     LayerTreeImpl* tree_impl) {
-  return PictureImageLayerImpl::Create(tree_impl, id());
+  return PictureImageLayerImpl::Create(tree_impl, id()).PassAs<LayerImpl>();
 }
 
 void PictureImageLayerImpl::GetDebugBorderProperties(
diff --git a/cc/layers/picture_image_layer_impl_unittest.cc b/cc/layers/picture_image_layer_impl_unittest.cc
index 3f1d36c..06f53ef 100644
--- a/cc/layers/picture_image_layer_impl_unittest.cc
+++ b/cc/layers/picture_image_layer_impl_unittest.cc
@@ -43,7 +43,8 @@ class PictureImageLayerImplTest : public testing::Test {
                    &shared_bitmap_manager_) {
     tiling_client_.SetTileSize(ImplSidePaintingSettings().default_tile_size);
     host_impl_.CreatePendingTree();
-    host_impl_.InitializeRenderer(FakeOutputSurface::Create3d());
+    host_impl_.InitializeRenderer(
+        FakeOutputSurface::Create3d().PassAs<OutputSurface>());
   }
 
   scoped_ptr<TestablePictureImageLayerImpl> CreateLayer(int id,
@@ -125,7 +126,7 @@ TEST_F(PictureImageLayerImplTest, IgnoreIdealContentScale) {
   EXPECT_EQ(1.f, pending_layer->tilings()->tiling_at(0)->contents_scale());
 
   // Push to active layer.
-  host_impl_.pending_tree()->SetRootLayer(pending_layer.Pass());
+  host_impl_.pending_tree()->SetRootLayer(pending_layer.PassAs<LayerImpl>());
   host_impl_.ActivateSyncTree();
   TestablePictureImageLayerImpl* active_layer =
       static_cast<TestablePictureImageLayerImpl*>(
diff --git a/cc/layers/picture_layer.cc b/cc/layers/picture_layer.cc
index 68d24ba..d175a57 100644
--- a/cc/layers/picture_layer.cc
+++ b/cc/layers/picture_layer.cc
@@ -29,7 +29,7 @@ PictureLayer::~PictureLayer() {
 }
 
 scoped_ptr<LayerImpl> PictureLayer::CreateLayerImpl(LayerTreeImpl* tree_impl) {
-  return PictureLayerImpl::Create(tree_impl, id());
+  return PictureLayerImpl::Create(tree_impl, id()).PassAs<LayerImpl>();
 }
 
 void PictureLayer::PushPropertiesTo(LayerImpl* base_layer) {
diff --git a/cc/layers/picture_layer_impl.cc b/cc/layers/picture_layer_impl.cc
index 8960a80..9a43916 100644
--- a/cc/layers/picture_layer_impl.cc
+++ b/cc/layers/picture_layer_impl.cc
@@ -89,7 +89,7 @@ const char* PictureLayerImpl::LayerTypeAsString() const {
 
 scoped_ptr<LayerImpl> PictureLayerImpl::CreateLayerImpl(
     LayerTreeImpl* tree_impl) {
-  return PictureLayerImpl::Create(tree_impl, id());
+  return PictureLayerImpl::Create(tree_impl, id()).PassAs<LayerImpl>();
 }
 
 void PictureLayerImpl::PushPropertiesTo(LayerImpl* base_layer) {
diff --git a/cc/layers/picture_layer_impl_perftest.cc b/cc/layers/picture_layer_impl_perftest.cc
index a969027..1aff9ad 100644
--- a/cc/layers/picture_layer_impl_perftest.cc
+++ b/cc/layers/picture_layer_impl_perftest.cc
@@ -46,7 +46,8 @@ class PictureLayerImplPerfTest : public testing::Test {
                kTimeCheckInterval) {}
 
   virtual void SetUp() OVERRIDE {
-    host_impl_.InitializeRenderer(FakeOutputSurface::Create3d());
+    host_impl_.InitializeRenderer(
+        FakeOutputSurface::Create3d().PassAs<OutputSurface>());
   }
 
   void SetupPendingTree(const gfx::Size& layer_bounds,
@@ -60,7 +61,7 @@ class PictureLayerImplPerfTest : public testing::Test {
     scoped_ptr<FakePictureLayerImpl> pending_layer =
         FakePictureLayerImpl::CreateWithPile(pending_tree, 7, pile);
     pending_layer->SetDrawsContent(true);
-    pending_tree->SetRootLayer(pending_layer.Pass());
+    pending_tree->SetRootLayer(pending_layer.PassAs<LayerImpl>());
 
     pending_layer_ = static_cast<FakePictureLayerImpl*>(
         host_impl_.pending_tree()->LayerById(7));
diff --git a/cc/layers/picture_layer_impl_unittest.cc b/cc/layers/picture_layer_impl_unittest.cc
index b2492d3..c72d19c 100644
--- a/cc/layers/picture_layer_impl_unittest.cc
+++ b/cc/layers/picture_layer_impl_unittest.cc
@@ -76,7 +76,8 @@ class PictureLayerImplTest : public testing::Test {
   }
 
   virtual void InitializeRenderer() {
-    host_impl_.InitializeRenderer(FakeOutputSurface::Create3d());
+    host_impl_.InitializeRenderer(
+        FakeOutputSurface::Create3d().PassAs<OutputSurface>());
   }
 
   void SetupDefaultTrees(const gfx::Size& layer_bounds) {
@@ -144,7 +145,7 @@ class PictureLayerImplTest : public testing::Test {
     scoped_ptr<FakePictureLayerImpl> pending_layer =
         FakePictureLayerImpl::CreateWithPile(pending_tree, id_, pile);
     pending_layer->SetDrawsContent(true);
-    pending_tree->SetRootLayer(pending_layer.Pass());
+    pending_tree->SetRootLayer(pending_layer.PassAs<LayerImpl>());
 
     pending_layer_ = static_cast<FakePictureLayerImpl*>(
         host_impl_.pending_tree()->LayerById(id_));
@@ -1293,8 +1294,8 @@ TEST_F(PictureLayerImplTest, ClampTilesToToMaxTileSize) {
       TestWebGraphicsContext3D::Create();
   context->set_max_texture_size(140);
   host_impl_.DidLoseOutputSurface();
-  host_impl_.InitializeRenderer(
-      FakeOutputSurface::Create3d(context.Pass()).Pass());
+  host_impl_.InitializeRenderer(FakeOutputSurface::Create3d(
+      context.Pass()).PassAs<OutputSurface>());
 
   SetupDrawPropertiesAndUpdateTiles(pending_layer_, 1.f, 1.f, 1.f, 1.f, false);
   ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings());
@@ -1340,8 +1341,8 @@ TEST_F(PictureLayerImplTest, ClampSingleTileToToMaxTileSize) {
       TestWebGraphicsContext3D::Create();
   context->set_max_texture_size(140);
   host_impl_.DidLoseOutputSurface();
-  host_impl_.InitializeRenderer(
-      FakeOutputSurface::Create3d(context.Pass()).Pass());
+  host_impl_.InitializeRenderer(FakeOutputSurface::Create3d(
+      context.Pass()).PassAs<OutputSurface>());
 
   SetupDrawPropertiesAndUpdateTiles(pending_layer_, 1.f, 1.f, 1.f, 1.f, false);
   ASSERT_LE(1u, pending_layer_->tilings()->num_tilings());
@@ -1859,7 +1860,7 @@ TEST_F(PictureLayerImplTest, ActivateUninitializedLayer) {
   scoped_ptr<FakePictureLayerImpl> pending_layer =
       FakePictureLayerImpl::CreateWithPile(pending_tree, id_, pending_pile);
   pending_layer->SetDrawsContent(true);
-  pending_tree->SetRootLayer(pending_layer.Pass());
+  pending_tree->SetRootLayer(pending_layer.PassAs<LayerImpl>());
 
   pending_layer_ = static_cast<FakePictureLayerImpl*>(
       host_impl_.pending_tree()->LayerById(id_));
@@ -2214,9 +2215,10 @@ class DeferredInitPictureLayerImplTest : public PictureLayerImplTest {
  public:
   virtual void InitializeRenderer() OVERRIDE {
     bool delegated_rendering = false;
-    host_impl_.InitializeRenderer(FakeOutputSurface::CreateDeferredGL(
-        scoped_ptr<SoftwareOutputDevice>(new SoftwareOutputDevice),
-        delegated_rendering));
+    host_impl_.InitializeRenderer(
+        FakeOutputSurface::CreateDeferredGL(
+            scoped_ptr<SoftwareOutputDevice>(new SoftwareOutputDevice),
+            delegated_rendering).PassAs<OutputSurface>());
   }
 
   virtual void SetUp() OVERRIDE {
@@ -3500,7 +3502,7 @@ TEST_F(PictureLayerImplTest, UpdateTilesForMasksWithNoVisibleContent) {
   mask->SetDrawsContent(true);
 
   FakePictureLayerImpl* pending_mask_content = mask.get();
-  layer_with_mask->SetMaskLayer(mask.Pass());
+  layer_with_mask->SetMaskLayer(mask.PassAs<LayerImpl>());
 
   scoped_ptr<FakePictureLayerImpl> child_of_layer_with_mask =
       FakePictureLayerImpl::Create(host_impl_.pending_tree(), 4);
@@ -3509,9 +3511,9 @@ TEST_F(PictureLayerImplTest, UpdateTilesForMasksWithNoVisibleContent) {
   child_of_layer_with_mask->SetContentBounds(bounds);
   child_of_layer_with_mask->SetDrawsContent(true);
 
-  layer_with_mask->AddChild(child_of_layer_with_mask.Pass());
+  layer_with_mask->AddChild(child_of_layer_with_mask.PassAs<LayerImpl>());
 
-  root->AddChild(layer_with_mask.Pass());
+  root->AddChild(layer_with_mask.PassAs<LayerImpl>());
 
   host_impl_.pending_tree()->SetRootLayer(root.Pass());
 
@@ -3525,7 +3527,8 @@ class PictureLayerImplTestWithDelegatingRenderer : public PictureLayerImplTest {
   PictureLayerImplTestWithDelegatingRenderer() : PictureLayerImplTest() {}
 
   virtual void InitializeRenderer() OVERRIDE {
-    host_impl_.InitializeRenderer(FakeOutputSurface::CreateDelegating3d());
+    host_impl_.InitializeRenderer(
+        FakeOutputSurface::CreateDelegating3d().PassAs<OutputSurface>());
   }
 };
 
diff --git a/cc/layers/solid_color_layer.cc b/cc/layers/solid_color_layer.cc
index 25e0ab8..5a1e26f 100644
--- a/cc/layers/solid_color_layer.cc
+++ b/cc/layers/solid_color_layer.cc
@@ -10,7 +10,7 @@ namespace cc {
 
 scoped_ptr<LayerImpl> SolidColorLayer::CreateLayerImpl(
     LayerTreeImpl* tree_impl) {
-  return SolidColorLayerImpl::Create(tree_impl, id());
+  return SolidColorLayerImpl::Create(tree_impl, id()).PassAs<LayerImpl>();
 }
 
 scoped_refptr<SolidColorLayer> SolidColorLayer::Create() {
diff --git a/cc/layers/solid_color_layer_impl.cc b/cc/layers/solid_color_layer_impl.cc
index 618ea53..5e0a640 100644
--- a/cc/layers/solid_color_layer_impl.cc
+++ b/cc/layers/solid_color_layer_impl.cc
@@ -24,7 +24,7 @@ SolidColorLayerImpl::~SolidColorLayerImpl() {}
 
 scoped_ptr<LayerImpl> SolidColorLayerImpl::CreateLayerImpl(
     LayerTreeImpl* tree_impl) {
-  return SolidColorLayerImpl::Create(tree_impl, id());
+  return SolidColorLayerImpl::Create(tree_impl, id()).PassAs<LayerImpl>();
 }
 
 void SolidColorLayerImpl::AppendSolidQuads(
diff --git a/cc/layers/solid_color_scrollbar_layer.cc b/cc/layers/solid_color_scrollbar_layer.cc
index 98b23a4..7ea7265 100644
--- a/cc/layers/solid_color_scrollbar_layer.cc
+++ b/cc/layers/solid_color_scrollbar_layer.cc
@@ -19,7 +19,8 @@ scoped_ptr<LayerImpl> SolidColorScrollbarLayer::CreateLayerImpl(
                                               thumb_thickness_,
                                               track_start_,
                                               is_left_side_vertical_scrollbar_,
-                                              kIsOverlayScrollbar);
+                                              kIsOverlayScrollbar)
+      .PassAs<LayerImpl>();
 }
 
 scoped_refptr<SolidColorScrollbarLayer> SolidColorScrollbarLayer::Create(
diff --git a/cc/layers/solid_color_scrollbar_layer_impl.cc b/cc/layers/solid_color_scrollbar_layer_impl.cc
index a0c9609..8fac881 100644
--- a/cc/layers/solid_color_scrollbar_layer_impl.cc
+++ b/cc/layers/solid_color_scrollbar_layer_impl.cc
@@ -38,7 +38,8 @@ scoped_ptr<LayerImpl> SolidColorScrollbarLayerImpl::CreateLayerImpl(
                                               thumb_thickness_,
                                               track_start_,
                                               is_left_side_vertical_scrollbar(),
-                                              is_overlay_scrollbar());
+                                              is_overlay_scrollbar())
+      .PassAs<LayerImpl>();
 }
 
 SolidColorScrollbarLayerImpl::SolidColorScrollbarLayerImpl(
diff --git a/cc/layers/surface_layer.cc b/cc/layers/surface_layer.cc
index ba577a0..3ca179f 100644
--- a/cc/layers/surface_layer.cc
+++ b/cc/layers/surface_layer.cc
@@ -24,7 +24,7 @@ void SurfaceLayer::SetSurfaceId(SurfaceId surface_id) {
 }
 
 scoped_ptr<LayerImpl> SurfaceLayer::CreateLayerImpl(LayerTreeImpl* tree_impl) {
-  return SurfaceLayerImpl::Create(tree_impl, id());
+  return SurfaceLayerImpl::Create(tree_impl, id()).PassAs<LayerImpl>();
 }
 
 bool SurfaceLayer::HasDrawableContent() const {
diff --git a/cc/layers/surface_layer_impl.cc b/cc/layers/surface_layer_impl.cc
index 352aca6..0b102f2 100644
--- a/cc/layers/surface_layer_impl.cc
+++ b/cc/layers/surface_layer_impl.cc
@@ -19,7 +19,7 @@ SurfaceLayerImpl::~SurfaceLayerImpl() {}
 
 scoped_ptr<LayerImpl> SurfaceLayerImpl::CreateLayerImpl(
     LayerTreeImpl* tree_impl) {
-  return SurfaceLayerImpl::Create(tree_impl, id());
+  return SurfaceLayerImpl::Create(tree_impl, id()).PassAs<LayerImpl>();
 }
 
 void SurfaceLayerImpl::SetSurfaceId(SurfaceId surface_id) {
diff --git a/cc/layers/texture_layer.cc b/cc/layers/texture_layer.cc
index d8634ea..3bccc7e 100644
--- a/cc/layers/texture_layer.cc
+++ b/cc/layers/texture_layer.cc
@@ -55,7 +55,7 @@ void TextureLayer::ClearTexture() {
 }
 
 scoped_ptr<LayerImpl> TextureLayer::CreateLayerImpl(LayerTreeImpl* tree_impl) {
-  return TextureLayerImpl::Create(tree_impl, id());
+  return TextureLayerImpl::Create(tree_impl, id()).PassAs<LayerImpl>();
 }
 
 void TextureLayer::SetFlipped(bool flipped) {
@@ -130,7 +130,7 @@ void TextureLayer::SetTextureMailboxInternal(
     holder_ref_ =
         TextureMailboxHolder::Create(mailbox, release_callback.Pass());
   } else {
-    holder_ref_ = nullptr;
+    holder_ref_.reset();
   }
   needs_set_mailbox_ = true;
   // If we are within a commit, no need to do it again immediately after.
@@ -296,7 +296,7 @@ scoped_ptr<TextureLayer::TextureMailboxHolder::MainThreadReference>
 TextureLayer::TextureMailboxHolder::Create(
     const TextureMailbox& mailbox,
     scoped_ptr<SingleReleaseCallback> release_callback) {
-  return make_scoped_ptr(new MainThreadReference(
+  return scoped_ptr<MainThreadReference>(new MainThreadReference(
       new TextureMailboxHolder(mailbox, release_callback.Pass())));
 }
 
@@ -326,7 +326,7 @@ void TextureLayer::TextureMailboxHolder::InternalRelease() {
   if (!--internal_references_) {
     release_callback_->Run(sync_point_, is_lost_);
     mailbox_ = TextureMailbox();
-    release_callback_ = nullptr;
+    release_callback_.reset();
   }
 }
 
diff --git a/cc/layers/texture_layer_impl.cc b/cc/layers/texture_layer_impl.cc
index 206d8db..d02689f 100644
--- a/cc/layers/texture_layer_impl.cc
+++ b/cc/layers/texture_layer_impl.cc
@@ -49,7 +49,7 @@ void TextureLayerImpl::SetTextureMailbox(
 
 scoped_ptr<LayerImpl> TextureLayerImpl::CreateLayerImpl(
     LayerTreeImpl* tree_impl) {
-  return TextureLayerImpl::Create(tree_impl, id());
+  return TextureLayerImpl::Create(tree_impl, id()).PassAs<LayerImpl>();
 }
 
 void TextureLayerImpl::PushPropertiesTo(LayerImpl* layer) {
@@ -83,7 +83,7 @@ bool TextureLayerImpl::WillDraw(DrawMode draw_mode,
           resource_provider->CreateResourceFromTextureMailbox(
               texture_mailbox_, release_callback_.Pass());
       DCHECK(external_texture_resource_);
-      texture_copy_ = nullptr;
+      texture_copy_.reset();
       valid_texture_copy_ = false;
     }
     if (external_texture_resource_)
@@ -194,7 +194,7 @@ SimpleEnclosedRegion TextureLayerImpl::VisibleContentOpaqueRegion() const {
 
 void TextureLayerImpl::ReleaseResources() {
   FreeTextureMailbox();
-  texture_copy_ = nullptr;
+  texture_copy_.reset();
   external_texture_resource_ = 0;
   valid_texture_copy_ = false;
 }
@@ -248,7 +248,7 @@ void TextureLayerImpl::FreeTextureMailbox() {
                              layer_tree_impl()->BlockingMainThreadTaskRunner());
     }
     texture_mailbox_ = TextureMailbox();
-    release_callback_ = nullptr;
+    release_callback_.reset();
   } else if (external_texture_resource_) {
     DCHECK(!own_mailbox_);
     ResourceProvider* resource_provider =
diff --git a/cc/layers/texture_layer_unittest.cc b/cc/layers/texture_layer_unittest.cc
index b3c48fb..feb7126 100644
--- a/cc/layers/texture_layer_unittest.cc
+++ b/cc/layers/texture_layer_unittest.cc
@@ -185,7 +185,7 @@ class TextureLayerTest : public testing::Test {
     EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AnyNumber());
 
     layer_tree_host_->SetRootLayer(NULL);
-    layer_tree_host_ = nullptr;
+    layer_tree_host_.reset();
   }
 
   scoped_ptr<MockLayerTreeHost> layer_tree_host_;
@@ -422,7 +422,9 @@ class TextureLayerMailboxHolderTest : public TextureLayerTest {
         SingleReleaseCallback::Create(test_data_.release_mailbox1_)).Pass();
   }
 
-  void ReleaseMainRef() { main_ref_ = nullptr; }
+  void ReleaseMainRef() {
+    main_ref_.reset();
+  }
 
   void CreateImplRef(scoped_ptr<SingleReleaseCallbackImpl>* impl_ref) {
     *impl_ref = main_ref_->holder()->GetCallbackForImplThread();
@@ -930,7 +932,8 @@ class TextureLayerImplWithMailboxTest : public TextureLayerTest {
   virtual void SetUp() {
     TextureLayerTest::SetUp();
     layer_tree_host_.reset(new MockLayerTreeHost(&fake_client_));
-    EXPECT_TRUE(host_impl_.InitializeRenderer(FakeOutputSurface::Create3d()));
+    EXPECT_TRUE(host_impl_.InitializeRenderer(
+        FakeOutputSurface::Create3d().PassAs<OutputSurface>()));
   }
 
   bool WillDraw(TextureLayerImpl* layer, DrawMode mode) {
diff --git a/cc/layers/tiled_layer.cc b/cc/layers/tiled_layer.cc
index 854a747..1f30b45 100644
--- a/cc/layers/tiled_layer.cc
+++ b/cc/layers/tiled_layer.cc
@@ -98,7 +98,7 @@ TiledLayer::TiledLayer()
 TiledLayer::~TiledLayer() {}
 
 scoped_ptr<LayerImpl> TiledLayer::CreateLayerImpl(LayerTreeImpl* tree_impl) {
-  return TiledLayerImpl::Create(tree_impl, id());
+  return TiledLayerImpl::Create(tree_impl, id()).PassAs<LayerImpl>();
 }
 
 void TiledLayer::UpdateTileSizeAndTilingOption() {
@@ -277,7 +277,7 @@ UpdatableTile* TiledLayer::CreateTile(int i, int j) {
   tile->managed_resource()->SetDimensions(tiler_->tile_size(), texture_format_);
 
   UpdatableTile* added_tile = tile.get();
-  tiler_->AddTile(tile.Pass(), i, j);
+  tiler_->AddTile(tile.PassAs<LayerTilingData::Tile>(), i, j);
 
   added_tile->dirty_rect = tiler_->TileRect(added_tile);
 
diff --git a/cc/layers/tiled_layer_impl.cc b/cc/layers/tiled_layer_impl.cc
index 18d9d1e..f7f9792 100644
--- a/cc/layers/tiled_layer_impl.cc
+++ b/cc/layers/tiled_layer_impl.cc
@@ -85,7 +85,7 @@ DrawableTile* TiledLayerImpl::TileAt(int i, int j) const {
 DrawableTile* TiledLayerImpl::CreateTile(int i, int j) {
   scoped_ptr<DrawableTile> tile(DrawableTile::Create());
   DrawableTile* added_tile = tile.get();
-  tiler_->AddTile(tile.Pass(), i, j);
+  tiler_->AddTile(tile.PassAs<LayerTilingData::Tile>(), i, j);
 
   return added_tile;
 }
@@ -98,7 +98,7 @@ void TiledLayerImpl::GetDebugBorderProperties(SkColor* color,
 
 scoped_ptr<LayerImpl> TiledLayerImpl::CreateLayerImpl(
     LayerTreeImpl* tree_impl) {
-  return TiledLayerImpl::Create(tree_impl, id());
+  return TiledLayerImpl::Create(tree_impl, id()).PassAs<LayerImpl>();
 }
 
 void TiledLayerImpl::AsValueInto(base::debug::TracedValue* state) const {
diff --git a/cc/layers/tiled_layer_unittest.cc b/cc/layers/tiled_layer_unittest.cc
index d2bc0a9..e46d66b7 100644
--- a/cc/layers/tiled_layer_unittest.cc
+++ b/cc/layers/tiled_layer_unittest.cc
@@ -140,8 +140,8 @@ class TiledLayerTest : public testing::Test {
 
     DebugScopedSetImplThreadAndMainThreadBlocked
     impl_thread_and_main_thread_blocked(proxy_);
-    resource_provider_ = nullptr;
-    host_impl_ = nullptr;
+    resource_provider_.reset();
+    host_impl_.reset();
   }
 
   void ResourceManagerClearAllMemory(
@@ -1665,8 +1665,10 @@ class UpdateTrackingTiledLayer : public FakeTiledLayer {
       : FakeTiledLayer(manager) {
     scoped_ptr<TrackingLayerPainter> painter(TrackingLayerPainter::Create());
     tracking_layer_painter_ = painter.get();
-    layer_updater_ = BitmapContentLayerUpdater::Create(
-        painter.Pass(), &stats_instrumentation_, 0);
+    layer_updater_ =
+        BitmapContentLayerUpdater::Create(painter.PassAs<LayerPainter>(),
+                                          &stats_instrumentation_,
+                                          0);
   }
 
   TrackingLayerPainter* tracking_layer_painter() const {
diff --git a/cc/layers/ui_resource_layer.cc b/cc/layers/ui_resource_layer.cc
index 498ba33..59fbe83 100644
--- a/cc/layers/ui_resource_layer.cc
+++ b/cc/layers/ui_resource_layer.cc
@@ -69,7 +69,7 @@ UIResourceLayer::~UIResourceLayer() {}
 
 scoped_ptr<LayerImpl> UIResourceLayer::CreateLayerImpl(
     LayerTreeImpl* tree_impl) {
-  return UIResourceLayerImpl::Create(tree_impl, id());
+  return UIResourceLayerImpl::Create(tree_impl, id()).PassAs<LayerImpl>();
 }
 
 void UIResourceLayer::SetUV(const gfx::PointF& top_left,
@@ -112,7 +112,7 @@ void UIResourceLayer::SetLayerTreeHost(LayerTreeHost* host) {
 }
 
 void UIResourceLayer::RecreateUIResourceHolder() {
-  ui_resource_holder_ = nullptr;
+  ui_resource_holder_.reset();
   if (layer_tree_host() && !bitmap_.empty()) {
     ui_resource_holder_ =
         ScopedUIResourceHolder::Create(layer_tree_host(), bitmap_);
@@ -131,10 +131,11 @@ void UIResourceLayer::SetUIResourceId(UIResourceId resource_id) {
   if (ui_resource_holder_ && ui_resource_holder_->id() == resource_id)
     return;
 
-  if (resource_id)
+  if (resource_id) {
     ui_resource_holder_ = SharedUIResourceHolder::Create(resource_id);
-  else
-    ui_resource_holder_ = nullptr;
+  } else {
+    ui_resource_holder_.reset();
+  }
 
   UpdateDrawsContent(HasDrawableContent());
   SetNeedsCommit();
diff --git a/cc/layers/ui_resource_layer_impl.cc b/cc/layers/ui_resource_layer_impl.cc
index 8a7d3df..98843c6 100644
--- a/cc/layers/ui_resource_layer_impl.cc
+++ b/cc/layers/ui_resource_layer_impl.cc
@@ -29,7 +29,7 @@ UIResourceLayerImpl::~UIResourceLayerImpl() {}
 
 scoped_ptr<LayerImpl> UIResourceLayerImpl::CreateLayerImpl(
     LayerTreeImpl* tree_impl) {
-  return UIResourceLayerImpl::Create(tree_impl, id());
+  return UIResourceLayerImpl::Create(tree_impl, id()).PassAs<LayerImpl>();
 }
 
 void UIResourceLayerImpl::PushPropertiesTo(LayerImpl* layer) {
diff --git a/cc/layers/video_layer.cc b/cc/layers/video_layer.cc
index fe37fbf4..995668b 100644
--- a/cc/layers/video_layer.cc
+++ b/cc/layers/video_layer.cc
@@ -25,7 +25,7 @@ VideoLayer::~VideoLayer() {}
 scoped_ptr<LayerImpl> VideoLayer::CreateLayerImpl(LayerTreeImpl* tree_impl) {
   scoped_ptr<VideoLayerImpl> impl =
       VideoLayerImpl::Create(tree_impl, id(), provider_, video_rotation_);
-  return impl.Pass();
+  return impl.PassAs<LayerImpl>();
 }
 
 bool VideoLayer::Update(ResourceUpdateQueue* queue,
diff --git a/cc/layers/video_layer_impl.cc b/cc/layers/video_layer_impl.cc
index 2edea94..4bfd1cd 100644
--- a/cc/layers/video_layer_impl.cc
+++ b/cc/layers/video_layer_impl.cc
@@ -59,7 +59,8 @@ VideoLayerImpl::~VideoLayerImpl() {
 
 scoped_ptr<LayerImpl> VideoLayerImpl::CreateLayerImpl(
     LayerTreeImpl* tree_impl) {
-  return make_scoped_ptr(new VideoLayerImpl(tree_impl, id(), video_rotation_));
+  VideoLayerImpl* impl = new VideoLayerImpl(tree_impl, id(), video_rotation_);
+  return scoped_ptr<LayerImpl>(impl);
 }
 
 void VideoLayerImpl::PushPropertiesTo(LayerImpl* layer) {
@@ -89,7 +90,7 @@ bool VideoLayerImpl::WillDraw(DrawMode draw_mode,
 
   if (!frame_.get()) {
     // Drop any resources used by the updater if there is no frame to display.
-    updater_ = nullptr;
+    updater_.reset();
 
     provider_client_impl_->ReleaseLock();
     return false;
@@ -357,7 +358,7 @@ void VideoLayerImpl::DidDraw(ResourceProvider* resource_provider) {
 }
 
 void VideoLayerImpl::ReleaseResources() {
-  updater_ = nullptr;
+  updater_.reset();
 }
 
 void VideoLayerImpl::SetNeedsRedraw() {