cc: Replace Pass() with std::move() in some subdirs.

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 <map>
 #include <set>
@@ skipping 460 matching lines @@
       gfx::SizeF(active_tree_->InnerViewportContainerLayer()->bounds());
 
   // Easing constants experimentally determined.
   scoped_ptr<TimingFunction> timing_function =
       CubicBezierTimingFunction::Create(.8, 0, .3, .9);
 
   // TODO(miletus) : Pass in ScrollOffset.
   page_scale_animation_ = PageScaleAnimation::Create(
       ScrollOffsetToVector2dF(scroll_total),
       active_tree_->current_page_scale_factor(), viewport_size,
-      scaled_scrollable_size, timing_function.Pass());
+      scaled_scrollable_size, std::move(timing_function));
 
   if (anchor_point) {
     gfx::Vector2dF anchor(target_offset);
     page_scale_animation_->ZoomWithAnchor(anchor,
                                           page_scale,
                                           duration.InSecondsF());
   } else {
     gfx::Vector2dF scaled_target_offset = target_offset;
     page_scale_animation_->ZoomTo(scaled_target_offset,
                                   page_scale,
@@ skipping 112 matching lines @@
   DCHECK(!scroll_elasticity_helper_);
   if (settings_.enable_elastic_overscroll) {
     scroll_elasticity_helper_.reset(
         ScrollElasticityHelper::CreateForLayerTreeHostImpl(this));
   }
   return scroll_elasticity_helper_.get();
 }
 
 void LayerTreeHostImpl::QueueSwapPromiseForMainThreadScrollUpdate(
     scoped_ptr<SwapPromise> swap_promise) {
-  swap_promises_for_main_thread_scroll_update_.push_back(swap_promise.Pass());
+  swap_promises_for_main_thread_scroll_update_.push_back(
+      std::move(swap_promise));
 }
 
 void LayerTreeHostImpl::TrackDamageForAllSurfaces(
     LayerImpl* root_draw_layer,
     const LayerImplList& render_surface_layer_list) {
   // For now, we use damage tracking to compute a global scissor. To do this, we
   // must compute all damage tracking before drawing anything, so that we know
   // the root damage rect. The root damage rect is then used to scissor each
   // surface.
   size_t render_surface_layer_list_size = render_surface_layer_list.size();
@@ skipping 27 matching lines @@
       value->BeginDictionary();
       render_passes[i]->AsValueInto(value);
       value->EndDictionary();
     }
     value->EndArray();
   }
 }
 
 void LayerTreeHostImpl::FrameData::AppendRenderPass(
     scoped_ptr<RenderPass> render_pass) {
-  render_passes.push_back(render_pass.Pass());
+  render_passes.push_back(std::move(render_pass));
 }
 
 DrawMode LayerTreeHostImpl::GetDrawMode() const {
   if (resourceless_software_draw_) {
     return DRAW_MODE_RESOURCELESS_SOFTWARE;
   } else if (output_surface_->context_provider()) {
     return DRAW_MODE_HARDWARE;
   } else {
     return DRAW_MODE_SOFTWARE;
   }
@@ skipping 1544 matching lines @@
 
   base::TimeTicks start_time = start_of_main_frame_args.frame_time;
   base::TimeTicks end_time = expected_next_main_frame_args.frame_time;
   frame_timing_tracker_->SaveMainFrameTimeStamps(
       request_ids, start_time, end_time, active_tree_->source_frame_number());
 }
 
 void LayerTreeHostImpl::PostFrameTimingEvents(
     scoped_ptr<FrameTimingTracker::CompositeTimingSet> composite_events,
     scoped_ptr<FrameTimingTracker::MainFrameTimingSet> main_frame_events) {
-  client_->PostFrameTimingEventsOnImplThread(composite_events.Pass(),
-                                             main_frame_events.Pass());
+  client_->PostFrameTimingEventsOnImplThread(std::move(composite_events),
+                                             std::move(main_frame_events));
 }
 
 void LayerTreeHostImpl::CleanUpTileManagerAndUIResources() {
   ClearUIResources();
   tile_manager_->FinishTasksAndCleanUp();
   resource_pool_ = nullptr;
   tile_task_worker_pool_ = nullptr;
   single_thread_synchronous_task_graph_runner_ = nullptr;
 }
 
@@ skipping 782 matching lines @@
 
   CollectScrollDeltas(scroll_info.get(), active_tree_->root_layer());
   scroll_info->page_scale_delta =
       active_tree_->page_scale_factor()->PullDeltaForMainThread();
   scroll_info->top_controls_delta =
       active_tree()->top_controls_shown_ratio()->PullDeltaForMainThread();
   scroll_info->elastic_overscroll_delta =
       active_tree_->elastic_overscroll()->PullDeltaForMainThread();
   scroll_info->swap_promises.swap(swap_promises_for_main_thread_scroll_update_);
 
-  return scroll_info.Pass();
+  return scroll_info;
 }
 
 void LayerTreeHostImpl::SetFullRootLayerDamage() {
   SetViewportDamage(gfx::Rect(DrawViewportSize()));
 }
 
 void LayerTreeHostImpl::ScrollViewportInnerFirst(gfx::Vector2dF scroll_delta) {
   DCHECK(InnerViewportScrollLayer());
   LayerImpl* scroll_layer = InnerViewportScrollLayer();
 
@@ skipping 106 matching lines @@
     events = animation_host_->CreateEvents();
     has_active_animations = animation_host_->UpdateAnimationState(
         start_ready_animations, events.get());
   } else {
     events = animation_registrar_->CreateEvents();
     has_active_animations = animation_registrar_->UpdateAnimationState(
         start_ready_animations, events.get());
   }
 
   if (!events->empty())
-    client_->PostAnimationEventsToMainThreadOnImplThread(events.Pass());
+    client_->PostAnimationEventsToMainThreadOnImplThread(std::move(events));
 
   if (has_active_animations)
     SetNeedsAnimate();
 }
 
 void LayerTreeHostImpl::ActivateAnimations() {
   if (!settings_.accelerated_animation_enabled)
     return;
 
   bool activated = false;
@@ skipping 274 matching lines @@
       evicted_ui_resources_.find(uid);
   if (found_in_evicted == evicted_ui_resources_.end())
     return;
   evicted_ui_resources_.erase(found_in_evicted);
   if (evicted_ui_resources_.empty())
     client_->OnCanDrawStateChanged(CanDraw());
 }
 
 void LayerTreeHostImpl::ScheduleMicroBenchmark(
     scoped_ptr<MicroBenchmarkImpl> benchmark) {
-  micro_benchmark_controller_.ScheduleRun(benchmark.Pass());
+  micro_benchmark_controller_.ScheduleRun(std::move(benchmark));
 }
 
 void LayerTreeHostImpl::InsertSwapPromiseMonitor(SwapPromiseMonitor* monitor) {
   swap_promise_monitor_.insert(monitor);
 }
 
 void LayerTreeHostImpl::RemoveSwapPromiseMonitor(SwapPromiseMonitor* monitor) {
   swap_promise_monitor_.erase(monitor);
 }
 
@@ skipping 27 matching lines @@
     return animation_host_->ImplOnlyScrollAnimationCreate(
         layer_impl->id(), target_offset, current_offset);
 
   scoped_ptr<ScrollOffsetAnimationCurve> curve =
       ScrollOffsetAnimationCurve::Create(
           target_offset, EaseInOutTimingFunction::Create(),
           ScrollOffsetAnimationCurve::DurationBehavior::CONSTANT);
   curve->SetInitialValue(current_offset);
 
   scoped_ptr<Animation> animation = Animation::Create(
-      curve.Pass(), AnimationIdProvider::NextAnimationId(),
+      std::move(curve), AnimationIdProvider::NextAnimationId(),
       AnimationIdProvider::NextGroupId(), Animation::SCROLL_OFFSET);
   animation->set_is_impl_only(true);
 
-  layer_impl->layer_animation_controller()->AddAnimation(animation.Pass());
+  layer_impl->layer_animation_controller()->AddAnimation(std::move(animation));
 }
 
 bool LayerTreeHostImpl::ScrollAnimationUpdateTarget(
     LayerImpl* layer_impl,
     const gfx::Vector2dF& scroll_delta) {
   if (animation_host_)
     return animation_host_->ImplOnlyScrollAnimationUpdateTarget(
         layer_impl->id(), scroll_delta, layer_impl->MaxScrollOffset(),
         CurrentBeginFrameArgs().frame_time);
 
@@ skipping 180 matching lines @@
   return task_runner_provider_->HasImplThread();
 }
 
 bool LayerTreeHostImpl::CommitToActiveTree() const {
   // In single threaded mode we skip the pending tree and commit directly to the
   // active tree.
   return !task_runner_provider_->HasImplThread();
 }
 
 }  // namespace cc