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

cc/trees/layer_tree_host.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.h"
 
 #include <algorithm>
 #include <stack>
 #include <string>
 
@@ skipping 50 matching lines @@
 
 scoped_ptr<LayerTreeHost> LayerTreeHost::CreateThreaded(
     scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner,
     InitParams* params) {
   DCHECK(params->main_task_runner.get());
   DCHECK(impl_task_runner.get());
   DCHECK(params->settings);
   scoped_ptr<LayerTreeHost> layer_tree_host(new LayerTreeHost(params));
   layer_tree_host->InitializeThreaded(
       params->main_task_runner, impl_task_runner,
-      params->external_begin_frame_source.Pass());
-  return layer_tree_host.Pass();
+      std::move(params->external_begin_frame_source));
+  return layer_tree_host;
 }
 
 scoped_ptr<LayerTreeHost> LayerTreeHost::CreateSingleThreaded(
     LayerTreeHostSingleThreadClient* single_thread_client,
     InitParams* params) {
   DCHECK(params->settings);
   scoped_ptr<LayerTreeHost> layer_tree_host(new LayerTreeHost(params));
   layer_tree_host->InitializeSingleThreaded(
       single_thread_client, params->main_task_runner,
-      params->external_begin_frame_source.Pass());
-  return layer_tree_host.Pass();
+      std::move(params->external_begin_frame_source));
+  return layer_tree_host;
 }
 
 LayerTreeHost::LayerTreeHost(InitParams* params)
     : micro_benchmark_controller_(this),
       next_ui_resource_id_(1),
       needs_full_tree_sync_(true),
       needs_meta_info_recomputation_(true),
       client_(params->client),
       source_frame_number_(0),
       meta_information_sequence_number_(1),
@@ skipping 39 matching lines @@
       debug_state_.RecordRenderingStats());
 }
 
 void LayerTreeHost::InitializeThreaded(
     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner,
     scoped_ptr<BeginFrameSource> external_begin_frame_source) {
   task_runner_provider_ =
       TaskRunnerProvider::Create(main_task_runner, impl_task_runner);
   InitializeProxy(ThreadProxy::Create(this, task_runner_provider_.get(),
-                                      external_begin_frame_source.Pass()));
+                                      std::move(external_begin_frame_source)));
 }
 
 void LayerTreeHost::InitializeSingleThreaded(
     LayerTreeHostSingleThreadClient* single_thread_client,
     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
     scoped_ptr<BeginFrameSource> external_begin_frame_source) {
   task_runner_provider_ = TaskRunnerProvider::Create(main_task_runner, nullptr);
   InitializeProxy(SingleThreadProxy::Create(
       this, single_thread_client, task_runner_provider_.get(),
-      external_begin_frame_source.Pass()));
+      std::move(external_begin_frame_source)));
 }
 
 void LayerTreeHost::InitializeForTesting(
     scoped_ptr<TaskRunnerProvider> task_runner_provider,
     scoped_ptr<Proxy> proxy_for_testing) {
-  task_runner_provider_ = task_runner_provider.Pass();
-  InitializeProxy(proxy_for_testing.Pass());
+  task_runner_provider_ = std::move(task_runner_provider);
+  InitializeProxy(std::move(proxy_for_testing));
 }
 
 void LayerTreeHost::InitializeProxy(scoped_ptr<Proxy> proxy) {
   TRACE_EVENT0("cc", "LayerTreeHost::InitializeForReal");
 
-  proxy_ = proxy.Pass();
+  proxy_ = std::move(proxy);
   proxy_->Start();
   if (settings_.accelerated_animation_enabled) {
     if (animation_host_)
       animation_host_->SetSupportsScrollAnimations(
           proxy_->SupportsImplScrolling());
     else
       animation_registrar_->set_supports_scroll_animations(
           proxy_->SupportsImplScrolling());
   }
 }
@@ skipping 137 matching lines @@
 
   host_impl->SetViewportSize(device_viewport_size_);
   // TODO(senorblanco): Move this up so that it happens before GPU rasterization
   // properties are set, since those trigger an update of GPU rasterization
   // status, which depends on the device scale factor. (crbug.com/535700)
   sync_tree->SetDeviceScaleFactor(device_scale_factor_);
   sync_tree->set_painted_device_scale_factor(painted_device_scale_factor_);
   host_impl->SetDebugState(debug_state_);
   if (pending_page_scale_animation_) {
     sync_tree->SetPendingPageScaleAnimation(
-        pending_page_scale_animation_.Pass());
+        std::move(pending_page_scale_animation_));
   }
 
   if (!ui_resource_request_queue_.empty()) {
     sync_tree->set_ui_resource_request_queue(ui_resource_request_queue_);
     ui_resource_request_queue_.clear();
   }
 
   DCHECK(!sync_tree->ViewportSizeInvalid());
 
   sync_tree->set_has_ever_been_drawn(false);
@@ skipping 45 matching lines @@
     did_complete_scale_animation_ = false;
   }
 }
 
 void LayerTreeHost::SetOutputSurface(scoped_ptr<OutputSurface> surface) {
   TRACE_EVENT0("cc", "LayerTreeHost::SetOutputSurface");
   DCHECK(output_surface_lost_);
   DCHECK(surface);
 
   DCHECK(!new_output_surface_);
-  new_output_surface_ = surface.Pass();
+  new_output_surface_ = std::move(surface);
   proxy_->SetOutputSurface(new_output_surface_.get());
 }
 
 scoped_ptr<OutputSurface> LayerTreeHost::ReleaseOutputSurface() {
   DCHECK(!visible_);
   DCHECK(!output_surface_lost_);
 
   DidLoseOutputSurface();
   proxy_->ReleaseOutputSurface();
-  return current_output_surface_.Pass();
+  return std::move(current_output_surface_);
 }
 
 void LayerTreeHost::RequestNewOutputSurface() {
   client_->RequestNewOutputSurface();
 }
 
 void LayerTreeHost::DidInitializeOutputSurface() {
   DCHECK(new_output_surface_);
   output_surface_lost_ = false;
-  current_output_surface_ = new_output_surface_.Pass();
+  current_output_surface_ = std::move(new_output_surface_);
   client_->DidInitializeOutputSurface();
 }
 
 void LayerTreeHost::DidFailToInitializeOutputSurface() {
   DCHECK(output_surface_lost_);
   DCHECK(new_output_surface_);
   // Note: It is safe to drop all output surface references here as
   // LayerTreeHostImpl will not keep a pointer to either the old or
   // new output surface after failing to initialize the new one.
   current_output_surface_ = nullptr;
   new_output_surface_ = nullptr;
   client_->DidFailToInitializeOutputSurface();
 }
 
 scoped_ptr<LayerTreeHostImpl> LayerTreeHost::CreateLayerTreeHostImpl(
     LayerTreeHostImplClient* client) {
   DCHECK(task_runner_provider_->IsImplThread());
   scoped_ptr<LayerTreeHostImpl> host_impl = LayerTreeHostImpl::Create(
       settings_, client, task_runner_provider_.get(),
       rendering_stats_instrumentation_.get(), shared_bitmap_manager_,
       gpu_memory_buffer_manager_, task_graph_runner_, id_);
   host_impl->SetHasGpuRasterizationTrigger(has_gpu_rasterization_trigger_);
   host_impl->SetContentIsSuitableForGpuRasterization(
       content_is_suitable_for_gpu_rasterization_);
   shared_bitmap_manager_ = NULL;
   gpu_memory_buffer_manager_ = NULL;
   task_graph_runner_ = NULL;
   input_handler_weak_ptr_ = host_impl->AsWeakPtr();
-  return host_impl.Pass();
+  return host_impl;
 }
 
 void LayerTreeHost::DidLoseOutputSurface() {
   TRACE_EVENT0("cc", "LayerTreeHost::DidLoseOutputSurface");
   DCHECK(task_runner_provider_->IsMainThread());
 
   if (output_surface_lost_)
     return;
 
   output_surface_lost_ = true;
@@ skipping 80 matching lines @@
 
 void LayerTreeHost::SetNextCommitForcesRedraw() {
   next_commit_forces_redraw_ = true;
   proxy_->SetNeedsUpdateLayers();
 }
 
 void LayerTreeHost::SetAnimationEvents(
     scoped_ptr<AnimationEventsVector> events) {
   DCHECK(task_runner_provider_->IsMainThread());
   if (animation_host_)
-    animation_host_->SetAnimationEvents(events.Pass());
+    animation_host_->SetAnimationEvents(std::move(events));
   else
-    animation_registrar_->SetAnimationEvents(events.Pass());
+    animation_registrar_->SetAnimationEvents(std::move(events));
 }
 
 void LayerTreeHost::SetRootLayer(scoped_refptr<Layer> root_layer) {
   if (root_layer_.get() == root_layer.get())
     return;
 
   if (root_layer_.get())
     root_layer_->SetLayerTreeHost(NULL);
   root_layer_ = root_layer;
   if (root_layer_.get()) {
@@ skipping 260 matching lines @@
   return did_paint_content;
 }
 
 void LayerTreeHost::ApplyScrollAndScale(ScrollAndScaleSet* info) {
   for (auto& swap_promise : info->swap_promises) {
     TRACE_EVENT_WITH_FLOW1("input,benchmark",
                            "LatencyInfo.Flow",
                            TRACE_ID_DONT_MANGLE(swap_promise->TraceId()),
                            TRACE_EVENT_FLAG_FLOW_IN | TRACE_EVENT_FLAG_FLOW_OUT,
                            "step", "Main thread scroll update");
-    QueueSwapPromise(swap_promise.Pass());
+    QueueSwapPromise(std::move(swap_promise));
   }
 
   gfx::Vector2dF inner_viewport_scroll_delta;
   gfx::Vector2dF outer_viewport_scroll_delta;
 
   if (root_layer_.get()) {
     for (size_t i = 0; i < info->scrolls.size(); ++i) {
       Layer* layer = LayerTreeHostCommon::FindLayerInSubtree(
           root_layer_.get(), info->scrolls[i].layer_id);
       if (!layer)
@@ skipping 158 matching lines @@
     return;
 
   selection_ = selection;
   SetNeedsCommit();
 }
 
 int LayerTreeHost::ScheduleMicroBenchmark(
     const std::string& benchmark_name,
     scoped_ptr<base::Value> value,
     const MicroBenchmark::DoneCallback& callback) {
-  return micro_benchmark_controller_.ScheduleRun(
-      benchmark_name, value.Pass(), callback);
+  return micro_benchmark_controller_.ScheduleRun(benchmark_name,
+                                                 std::move(value), callback);
 }
 
 bool LayerTreeHost::SendMessageToMicroBenchmark(int id,
                                                 scoped_ptr<base::Value> value) {
-  return micro_benchmark_controller_.SendMessage(id, value.Pass());
+  return micro_benchmark_controller_.SendMessage(id, std::move(value));
 }
 
 void LayerTreeHost::InsertSwapPromiseMonitor(SwapPromiseMonitor* monitor) {
   swap_promise_monitor_.insert(monitor);
 }
 
 void LayerTreeHost::RemoveSwapPromiseMonitor(SwapPromiseMonitor* monitor) {
   swap_promise_monitor_.erase(monitor);
 }
 
 void LayerTreeHost::NotifySwapPromiseMonitorsOfSetNeedsCommit() {
   std::set<SwapPromiseMonitor*>::iterator it = swap_promise_monitor_.begin();
   for (; it != swap_promise_monitor_.end(); it++)
     (*it)->OnSetNeedsCommitOnMain();
 }
 
 void LayerTreeHost::QueueSwapPromise(scoped_ptr<SwapPromise> swap_promise) {
   DCHECK(swap_promise);
-  swap_promise_list_.push_back(swap_promise.Pass());
+  swap_promise_list_.push_back(std::move(swap_promise));
 }
 
 void LayerTreeHost::BreakSwapPromises(SwapPromise::DidNotSwapReason reason) {
   for (const auto& swap_promise : swap_promise_list_)
     swap_promise->DidNotSwap(reason);
   swap_promise_list_.clear();
 }
 
 void LayerTreeHost::OnCommitForSwapPromises() {
   for (const auto& swap_promise : swap_promise_list_)
@@ skipping 19 matching lines @@
 }
 
 void LayerTreeHost::SetAuthoritativeVSyncInterval(
     const base::TimeDelta& interval) {
   proxy_->SetAuthoritativeVSyncInterval(interval);
 }
 
 void LayerTreeHost::RecordFrameTimingEvents(
     scoped_ptr<FrameTimingTracker::CompositeTimingSet> composite_events,
     scoped_ptr<FrameTimingTracker::MainFrameTimingSet> main_frame_events) {
-  client_->RecordFrameTimingEvents(composite_events.Pass(),
-                                   main_frame_events.Pass());
+  client_->RecordFrameTimingEvents(std::move(composite_events),
+                                   std::move(main_frame_events));
 }
 
 Layer* LayerTreeHost::LayerById(int id) const {
   LayerIdMap::const_iterator iter = layer_id_map_.find(id);
   return iter != layer_id_map_.end() ? iter->second : NULL;
 }
 
 void LayerTreeHost::RegisterLayer(Layer* layer) {
   DCHECK(!LayerById(layer->id()));
   DCHECK(!in_paint_layer_contents_);
@@ skipping 165 matching lines @@
   return animation_host_ ? animation_host_->HasAnyAnimation(layer->id())
                          : false;
 }
 
 bool LayerTreeHost::HasActiveAnimation(const Layer* layer) const {
   return animation_host_ ? animation_host_->HasActiveAnimation(layer->id())
                          : false;
 }
 
 }  // namespace cc