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

cc/trees/thread_proxy.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/thread_proxy.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/auto_reset.h"
@@ skipping 31 matching lines @@
 
 struct ThreadProxy::SchedulerStateRequest {
   CompletionEvent completion;
   scoped_ptr<base::Value> state;
 };
 
 scoped_ptr<Proxy> ThreadProxy::Create(
     LayerTreeHost* layer_tree_host,
     TaskRunnerProvider* task_runner_provider,
     scoped_ptr<BeginFrameSource> external_begin_frame_source) {
-  return make_scoped_ptr(new ThreadProxy(layer_tree_host, task_runner_provider,
-                                         external_begin_frame_source.Pass()));
+  return make_scoped_ptr(
+      new ThreadProxy(layer_tree_host, task_runner_provider,
+                      std::move(external_begin_frame_source)));
 }
 
 ThreadProxy::ThreadProxy(
     LayerTreeHost* layer_tree_host,
     TaskRunnerProvider* task_runner_provider,
     scoped_ptr<BeginFrameSource> external_begin_frame_source)
     : task_runner_provider_(task_runner_provider),
       main_thread_only_vars_unsafe_(this, layer_tree_host),
       compositor_thread_vars_unsafe_(
           this,
           layer_tree_host->id(),
           layer_tree_host->rendering_stats_instrumentation(),
-          external_begin_frame_source.Pass()) {
+          std::move(external_begin_frame_source)) {
   TRACE_EVENT0("cc", "ThreadProxy::ThreadProxy");
   DCHECK(task_runner_provider_);
   DCHECK(task_runner_provider_->IsMainThread());
   DCHECK(this->main().layer_tree_host);
   // TODO(khushalsagar): Move this to LayerTreeHost#InitializeThreaded once
   // ThreadProxy is split. LayerTreeHost creates the channel and passes it to
   // ProxyMain#SetChannel.
   SetChannel(ThreadedChannel::Create(this, task_runner_provider_));
 }
 
@@ skipping 27 matching lines @@
       commit_completion_event(nullptr),
       next_frame_is_newly_committed_frame(false),
       inside_draw(false),
       input_throttled_until_commit(false),
       smoothness_priority_expiration_notifier(
           proxy->task_runner_provider()
               ->ImplThreadTaskRunner(),
           base::Bind(&ThreadProxy::RenewTreePriority, base::Unretained(proxy)),
           base::TimeDelta::FromMilliseconds(
               kSmoothnessTakesPriorityExpirationDelay * 1000)),
-      external_begin_frame_source(external_begin_frame_source.Pass()),
+      external_begin_frame_source(std::move(external_begin_frame_source)),
       rendering_stats_instrumentation(rendering_stats_instrumentation),
       weak_factory(proxy) {}
 
 ThreadProxy::CompositorThreadOnly::~CompositorThreadOnly() {}
 
 ThreadProxy::~ThreadProxy() {
   TRACE_EVENT0("cc", "ThreadProxy::~ThreadProxy");
   DCHECK(task_runner_provider_->IsMainThread());
   DCHECK(!main().started);
 }
 
 void ThreadProxy::SetChannel(scoped_ptr<ThreadedChannel> threaded_channel) {
-  threaded_channel_ = threaded_channel.Pass();
+  threaded_channel_ = std::move(threaded_channel);
   main().channel_main = threaded_channel_.get();
 }
 
 void ThreadProxy::FinishAllRendering() {
   DCHECK(task_runner_provider_->IsMainThread());
   DCHECK(!main().defer_commits);
 
   // Make sure all GL drawing is finished on the impl thread.
   DebugScopedSetMainThreadBlocked main_thread_blocked(task_runner_provider_);
   CompletionEvent completion;
@@ skipping 231 matching lines @@
   // In tests the layer tree is destroyed after the scheduler is.
   if (impl().scheduler)
     impl().scheduler->SetVideoNeedsBeginFrames(needs_begin_frames);
 }
 
 void ThreadProxy::PostAnimationEventsToMainThreadOnImplThread(
     scoped_ptr<AnimationEventsVector> events) {
   TRACE_EVENT0("cc",
                "ThreadProxy::PostAnimationEventsToMainThreadOnImplThread");
   DCHECK(task_runner_provider_->IsImplThread());
-  impl().channel_impl->SetAnimationEvents(events.Pass());
+  impl().channel_impl->SetAnimationEvents(std::move(events));
 }
 
 bool ThreadProxy::IsInsideDraw() { return impl().inside_draw; }
 
 void ThreadProxy::SetNeedsRedraw(const gfx::Rect& damage_rect) {
   TRACE_EVENT0("cc", "ThreadProxy::SetNeedsRedraw");
   DCHECK(task_runner_provider_->IsMainThread());
   main().channel_main->SetNeedsRedrawOnImpl(damage_rect);
 }
 
@@ skipping 177 matching lines @@
   begin_main_frame_state->scroll_info =
       impl().layer_tree_host_impl->ProcessScrollDeltas();
   begin_main_frame_state->memory_allocation_limit_bytes =
       impl().layer_tree_host_impl->memory_allocation_limit_bytes();
   begin_main_frame_state->evicted_ui_resources =
       impl().layer_tree_host_impl->EvictedUIResourcesExist();
   // TODO(vmpstr): This needs to be fixed if
   // main_frame_before_activation_enabled is set, since we might run this code
   // twice before recording a duration. crbug.com/469824
   impl().last_begin_main_frame_args = begin_main_frame_state->begin_frame_args;
-  impl().channel_impl->BeginMainFrame(begin_main_frame_state.Pass());
+  impl().channel_impl->BeginMainFrame(std::move(begin_main_frame_state));
   devtools_instrumentation::DidRequestMainThreadFrame(
       impl().layer_tree_host_id);
 }
 
 void ThreadProxy::SendBeginMainFrameNotExpectedSoon() {
   impl().channel_impl->BeginMainFrameNotExpectedSoon();
 }
 
 void ThreadProxy::BeginMainFrame(
     scoped_ptr<BeginMainFrameAndCommitState> begin_main_frame_state) {
@@ skipping 342 matching lines @@
 }
 
 void ThreadProxy::DidCompleteSwapBuffers() {
   DCHECK(task_runner_provider_->IsMainThread());
   main().layer_tree_host->DidCompleteSwapBuffers();
 }
 
 void ThreadProxy::SetAnimationEvents(scoped_ptr<AnimationEventsVector> events) {
   TRACE_EVENT0("cc", "ThreadProxy::SetAnimationEvents");
   DCHECK(task_runner_provider_->IsMainThread());
-  main().layer_tree_host->SetAnimationEvents(events.Pass());
+  main().layer_tree_host->SetAnimationEvents(std::move(events));
 }
 
 void ThreadProxy::InitializeImplOnImpl(CompletionEvent* completion,
                                        LayerTreeHost* layer_tree_host) {
   TRACE_EVENT0("cc", "ThreadProxy::InitializeImplOnImplThread");
   DCHECK(task_runner_provider_->IsImplThread());
   DCHECK(task_runner_provider_->IsMainThreadBlocked());
   DCHECK(layer_tree_host);
 
   // TODO(khushalsagar): ThreadedChannel will create ProxyImpl here and pass a
   // reference to itself.
   impl().channel_impl = threaded_channel_.get();
 
   impl().layer_tree_host_impl = layer_tree_host->CreateLayerTreeHostImpl(this);
 
   SchedulerSettings scheduler_settings(
       layer_tree_host->settings().ToSchedulerSettings());
 
   scoped_ptr<CompositorTimingHistory> compositor_timing_history(
       new CompositorTimingHistory(CompositorTimingHistory::RENDERER_UMA,
                                   impl().rendering_stats_instrumentation));
 
   impl().scheduler =
       Scheduler::Create(this, scheduler_settings, impl().layer_tree_host_id,
                         task_runner_provider_->ImplThreadTaskRunner(),
                         impl().external_begin_frame_source.get(),
-                        compositor_timing_history.Pass());
+                        std::move(compositor_timing_history));
 
   DCHECK_EQ(impl().scheduler->visible(),
             impl().layer_tree_host_impl->visible());
   impl_thread_weak_ptr_ = impl().weak_factory.GetWeakPtr();
   completion->Signal();
 }
 
 void ThreadProxy::InitializeOutputSurfaceOnImpl(OutputSurface* output_surface) {
   TRACE_EVENT0("cc", "ThreadProxy::InitializeOutputSurfaceOnImplThread");
   DCHECK(task_runner_provider_->IsImplThread());
@@ skipping 184 matching lines @@
                                                bool animate) {
   DCHECK(task_runner_provider_->IsImplThread());
   impl().layer_tree_host_impl->top_controls_manager()->UpdateTopControlsState(
       constraints, current, animate);
 }
 
 void ThreadProxy::PostFrameTimingEventsOnImplThread(
     scoped_ptr<FrameTimingTracker::CompositeTimingSet> composite_events,
     scoped_ptr<FrameTimingTracker::MainFrameTimingSet> main_frame_events) {
   DCHECK(task_runner_provider_->IsImplThread());
-  impl().channel_impl->PostFrameTimingEventsOnMain(composite_events.Pass(),
-                                                   main_frame_events.Pass());
+  impl().channel_impl->PostFrameTimingEventsOnMain(
+      std::move(composite_events), std::move(main_frame_events));
 }
 
 void ThreadProxy::PostFrameTimingEventsOnMain(
     scoped_ptr<FrameTimingTracker::CompositeTimingSet> composite_events,
     scoped_ptr<FrameTimingTracker::MainFrameTimingSet> main_frame_events) {
   DCHECK(task_runner_provider_->IsMainThread());
-  main().layer_tree_host->RecordFrameTimingEvents(composite_events.Pass(),
-                                                  main_frame_events.Pass());
+  main().layer_tree_host->RecordFrameTimingEvents(std::move(composite_events),
+                                                  std::move(main_frame_events));
 }
 
 base::WeakPtr<ProxyMain> ThreadProxy::GetMainWeakPtr() {
   return main_thread_weak_ptr_;
 }
 
 base::WeakPtr<ProxyImpl> ThreadProxy::GetImplWeakPtr() {
   return impl_thread_weak_ptr_;
 }
 
 }  // namespace cc