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

cc/layers/video_layer_impl.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/layers/video_layer_impl.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "cc/layers/video_frame_provider_client_impl.h"
 #include "cc/quads/io_surface_draw_quad.h"
@@ skipping 41 matching lines @@
     // LayerImpl (the one on the pending tree) is destroyed since we know
     // the main thread is blocked for this commit.
     DCHECK(layer_tree_impl()->proxy()->IsImplThread());
     DCHECK(layer_tree_impl()->proxy()->IsMainThreadBlocked());
     provider_client_impl_->Stop();
   }
 }
 
 scoped_ptr<LayerImpl> VideoLayerImpl::CreateLayerImpl(
     LayerTreeImpl* tree_impl) {
-  VideoLayerImpl* impl = new VideoLayerImpl(tree_impl, id(), video_rotation_);
-  return scoped_ptr<LayerImpl>(impl);
+  return make_scoped_ptr(new VideoLayerImpl(tree_impl, id(), video_rotation_));
 }
 
 void VideoLayerImpl::PushPropertiesTo(LayerImpl* layer) {
   LayerImpl::PushPropertiesTo(layer);
 
   VideoLayerImpl* other = static_cast<VideoLayerImpl*>(layer);
   other->SetProviderClientImpl(provider_client_impl_);
 }
 
 void VideoLayerImpl::DidBecomeActive() {
   provider_client_impl_->set_active_video_layer(this);
 }
 
 bool VideoLayerImpl::WillDraw(DrawMode draw_mode,
                               ResourceProvider* resource_provider) {
   if (draw_mode == DRAW_MODE_RESOURCELESS_SOFTWARE)
     return false;
 
   // Explicitly acquire and release the provider mutex so it can be held from
   // WillDraw to DidDraw. Since the compositor thread is in the middle of
   // drawing, the layer will not be destroyed before DidDraw is called.
   // Therefore, the only thing that will prevent this lock from being released
   // is the GPU process locking it. As the GPU process can't cause the
   // destruction of the provider (calling StopUsingProvider), holding this
   // lock should not cause a deadlock.
   frame_ = provider_client_impl_->AcquireLockAndCurrentFrame();
 
   if (!frame_.get()) {
     // Drop any resources used by the updater if there is no frame to display.
-    updater_.reset();
+    updater_ = nullptr;
 
     provider_client_impl_->ReleaseLock();
     return false;
   }
 
   if (!LayerImpl::WillDraw(draw_mode, resource_provider))
     return false;
 
   if (!updater_) {
     updater_.reset(
@@ skipping 247 matching lines @@
     frame_resources_.clear();
   }
 
   provider_client_impl_->PutCurrentFrame(frame_);
   frame_ = NULL;
 
   provider_client_impl_->ReleaseLock();
 }
 
 void VideoLayerImpl::ReleaseResources() {
-  updater_.reset();
+  updater_ = nullptr;
 }
 
 void VideoLayerImpl::SetNeedsRedraw() {
   SetUpdateRect(gfx::UnionRects(update_rect(), gfx::RectF(bounds())));
   layer_tree_impl()->SetNeedsRedraw();
 }
 
 void VideoLayerImpl::SetProviderClientImpl(
     scoped_refptr<VideoFrameProviderClientImpl> provider_client_impl) {
   provider_client_impl_ = provider_client_impl;
 }
 
 const char* VideoLayerImpl::LayerTypeAsString() const {
   return "cc::VideoLayerImpl";
 }
 
 }  // namespace cc