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

cc/trees/layer_tree_host_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/trees/layer_tree_host_impl.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/basictypes.h"
@@ skipping 291 matching lines @@
   }
 
   // The layer trees must be destroyed before the layer tree host. We've
   // made a contract with our animation controllers that the registrar
   // will outlive them, and we must make good.
   if (recycle_tree_)
     recycle_tree_->Shutdown();
   if (pending_tree_)
     pending_tree_->Shutdown();
   active_tree_->Shutdown();
-  recycle_tree_.reset();
-  pending_tree_.reset();
-  active_tree_.reset();
+  recycle_tree_ = nullptr;
+  pending_tree_ = nullptr;
+  active_tree_ = nullptr;
   DestroyTileManager();
 }
 
 void LayerTreeHostImpl::BeginMainFrameAborted(bool did_handle) {
   // If the begin frame data was handled, then scroll and scale set was applied
   // by the main thread, so the active tree needs to be updated as if these sent
   // values were applied and committed.
   if (did_handle) {
     active_tree_->ApplySentScrollAndScaleDeltasFromAbortedCommit();
     active_tree_->ResetContentsTexturesPurged();
@@ skipping 114 matching lines @@
   if (!InnerViewportScrollLayer())
     return;
 
   gfx::Vector2dF scroll_total = active_tree_->TotalScrollOffset();
   gfx::SizeF scaled_scrollable_size = active_tree_->ScrollableSize();
   gfx::SizeF viewport_size =
       active_tree_->InnerViewportContainerLayer()->bounds();
 
   // Easing constants experimentally determined.
   scoped_ptr<TimingFunction> timing_function =
-      CubicBezierTimingFunction::Create(.8, 0, .3, .9).PassAs<TimingFunction>();
+      CubicBezierTimingFunction::Create(.8, 0, .3, .9);
 
   page_scale_animation_ =
       PageScaleAnimation::Create(scroll_total,
                                  active_tree_->total_page_scale_factor(),
                                  viewport_size,
                                  scaled_scrollable_size,
                                  timing_function.Pass());
 
   if (anchor_point) {
     gfx::Vector2dF anchor(target_offset);
@@ skipping 39 matching lines @@
   LayerImpl* layer_impl =
       active_tree_->FindLayerThatIsHitByPointInTouchHandlerRegion(
           device_viewport_point);
 
   return layer_impl != NULL;
 }
 
 scoped_ptr<SwapPromiseMonitor>
 LayerTreeHostImpl::CreateLatencyInfoSwapPromiseMonitor(
     ui::LatencyInfo* latency) {
-  return scoped_ptr<SwapPromiseMonitor>(
+  return make_scoped_ptr(
       new LatencyInfoSwapPromiseMonitor(latency, NULL, this));
 }
 
 void LayerTreeHostImpl::QueueSwapPromiseForMainThreadScrollUpdate(
     scoped_ptr<SwapPromise> swap_promise) {
   swap_promises_for_main_thread_scroll_update_.push_back(swap_promise.Pass());
 }
 
 void LayerTreeHostImpl::TrackDamageForAllSurfaces(
     LayerImpl* root_draw_layer,
@@ skipping 644 matching lines @@
   SetFullRootLayerDamage();
   DidInitializeVisibleTile();
 }
 
 void LayerTreeHostImpl::ResetTreesForTesting() {
   if (active_tree_)
     active_tree_->DetachLayerTree();
   active_tree_ = LayerTreeImpl::create(this);
   if (pending_tree_)
     pending_tree_->DetachLayerTree();
-  pending_tree_.reset();
+  pending_tree_ = nullptr;
   if (recycle_tree_)
     recycle_tree_->DetachLayerTree();
-  recycle_tree_.reset();
+  recycle_tree_ = nullptr;
 }
 
 void LayerTreeHostImpl::ResetRecycleTreeForTesting() {
   if (recycle_tree_)
     recycle_tree_->DetachLayerTree();
-  recycle_tree_.reset();
+  recycle_tree_ = nullptr;
 }
 
 void LayerTreeHostImpl::EnforceManagedMemoryPolicy(
     const ManagedMemoryPolicy& policy) {
 
   bool evicted_resources = client_->ReduceContentsTextureMemoryOnImplThread(
       visible_ ? policy.bytes_limit_when_visible : 0,
       ManagedMemoryPolicy::PriorityCutoffToValue(
           visible_ ? policy.priority_cutoff_when_visible
                    : gpu::MemoryAllocation::CUTOFF_ALLOW_NOTHING));
@@ skipping 840 matching lines @@
                           proxy_->ImplThreadTaskRunner(),
                           resource_pool_.get(),
                           raster_worker_pool_->AsRasterizer(),
                           rendering_stats_instrumentation_);
 
   UpdateTileManagerMemoryPolicy(ActualManagedMemoryPolicy());
   need_to_update_visible_tiles_before_draw_ = false;
 }
 
 void LayerTreeHostImpl::DestroyTileManager() {
-  tile_manager_.reset();
-  resource_pool_.reset();
-  staging_resource_pool_.reset();
-  raster_worker_pool_.reset();
+  tile_manager_ = nullptr;
+  resource_pool_ = nullptr;
+  staging_resource_pool_ = nullptr;
+  raster_worker_pool_ = nullptr;
 }
 
 bool LayerTreeHostImpl::UsePendingTreeForSync() const {
   // In impl-side painting, synchronize to the pending tree so that it has
   // time to raster before being displayed.
   return settings_.impl_side_painting;
 }
 
 bool LayerTreeHostImpl::UseZeroCopyRasterizer() const {
   return settings_.use_zero_copy && GetRendererCapabilities().using_map_image;
@@ skipping 12 matching lines @@
 bool LayerTreeHostImpl::InitializeRenderer(
     scoped_ptr<OutputSurface> output_surface) {
   TRACE_EVENT0("cc", "LayerTreeHostImpl::InitializeRenderer");
 
   // Since we will create a new resource provider, we cannot continue to use
   // the old resources (i.e. render_surfaces and texture IDs). Clear them
   // before we destroy the old resource provider.
   ReleaseTreeResources();
 
   // Note: order is important here.
-  renderer_.reset();
+  renderer_ = nullptr;
   DestroyTileManager();
-  resource_provider_.reset();
-  output_surface_.reset();
+  resource_provider_ = nullptr;
+  output_surface_ = nullptr;
 
   if (!output_surface->BindToClient(this))
     return false;
 
   output_surface_ = output_surface.Pass();
   resource_provider_ =
       ResourceProvider::Create(output_surface_.get(),
                                shared_bitmap_manager_,
                                proxy_->blocking_main_thread_task_runner(),
                                settings_.highp_threshold_min,
@@ skipping 41 matching lines @@
                                               base::TimeDelta interval) {
   client_->CommitVSyncParameters(timebase, interval);
 }
 
 void LayerTreeHostImpl::DeferredInitialize() {
   DCHECK(output_surface_->capabilities().deferred_gl_initialization);
   DCHECK(settings_.impl_side_painting);
   DCHECK(output_surface_->context_provider());
 
   ReleaseTreeResources();
-  renderer_.reset();
+  renderer_ = nullptr;
   DestroyTileManager();
 
   resource_provider_->InitializeGL();
 
   CreateAndSetRenderer();
   EnforceZeroBudget(false);
   CreateAndSetTileManager();
 
   client_->SetNeedsCommitOnImplThread();
 }
 
 void LayerTreeHostImpl::ReleaseGL() {
   DCHECK(output_surface_->capabilities().deferred_gl_initialization);
   DCHECK(settings_.impl_side_painting);
   DCHECK(output_surface_->context_provider());
 
   ReleaseTreeResources();
-  renderer_.reset();
+  renderer_ = nullptr;
   DestroyTileManager();
 
   resource_provider_->InitializeSoftware();
   output_surface_->ReleaseContextProvider();
 
   CreateAndSetRenderer();
   EnforceZeroBudget(true);
   CreateAndSetTileManager();
 
   client_->SetNeedsCommitOnImplThread();
@@ skipping 247 matching lines @@
       }
 
       active_tree_->SetCurrentlyScrollingLayer(layer_impl);
 
       scoped_ptr<ScrollOffsetAnimationCurve> curve =
           ScrollOffsetAnimationCurve::Create(target_offset,
                                              EaseInOutTimingFunction::Create());
       curve->SetInitialValue(current_offset);
 
       scoped_ptr<Animation> animation =
-          Animation::Create(curve.PassAs<AnimationCurve>(),
+          Animation::Create(curve.Pass(),
                             AnimationIdProvider::NextAnimationId(),
                             AnimationIdProvider::NextGroupId(),
                             Animation::ScrollOffset);
       animation->set_is_impl_only(true);
 
       layer_impl->layer_animation_controller()->AddAnimation(animation.Pass());
 
       SetNeedsAnimate();
       return ScrollStarted;
     }
@@ skipping 543 matching lines @@
   active_tree_->SetPageScaleDelta(
       page_scale_animation_->PageScaleFactorAtTime(monotonic_time) /
       active_tree_->page_scale_factor());
   gfx::Vector2dF next_scroll =
       page_scale_animation_->ScrollOffsetAtTime(monotonic_time);
 
   ScrollViewportBy(next_scroll - scroll_total);
   SetNeedsRedraw();
 
   if (page_scale_animation_->IsAnimationCompleteAtTime(monotonic_time)) {
-    page_scale_animation_.reset();
+    page_scale_animation_ = nullptr;
     client_->SetNeedsCommitOnImplThread();
     client_->RenewTreePriority();
   } else {
     SetNeedsAnimate();
   }
 }
 
 void LayerTreeHostImpl::AnimateTopControls(base::TimeTicks time) {
   if (!top_controls_manager_ || !top_controls_manager_->animation())
     return;
@@ skipping 385 matching lines @@
 }
 
 void LayerTreeHostImpl::UnregisterPictureLayerImpl(PictureLayerImpl* layer) {
   std::vector<PictureLayerImpl*>::iterator it =
       std::find(picture_layers_.begin(), picture_layers_.end(), layer);
   DCHECK(it != picture_layers_.end());
   picture_layers_.erase(it);
 }
 
 }  // namespace cc