Convert Pass()→std::move() in ui/

ui/wm/core/nested_accelerator_controller.cc

 // Copyright 2014 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 "ui/wm/core/nested_accelerator_controller.h"
 
+#include <utility>
+
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/run_loop.h"
 #include "ui/wm/core/nested_accelerator_delegate.h"
 #include "ui/wm/core/nested_accelerator_dispatcher.h"
 
 namespace wm {
 
 NestedAcceleratorController::NestedAcceleratorController(
     NestedAcceleratorDelegate* delegate)
     : dispatcher_delegate_(delegate) {
   DCHECK(delegate);
 }
 
 NestedAcceleratorController::~NestedAcceleratorController() {
 }
 
 void NestedAcceleratorController::PrepareNestedLoopClosures(
     base::MessagePumpDispatcher* nested_dispatcher,
     base::Closure* run_closure,
     base::Closure* quit_closure) {
   scoped_ptr<NestedAcceleratorDispatcher> old_accelerator_dispatcher =
-      accelerator_dispatcher_.Pass();
+      std::move(accelerator_dispatcher_);
   accelerator_dispatcher_ = NestedAcceleratorDispatcher::Create(
       dispatcher_delegate_.get(), nested_dispatcher);
 
   scoped_ptr<base::RunLoop> run_loop = accelerator_dispatcher_->CreateRunLoop();
   *quit_closure =
       base::Bind(&NestedAcceleratorController::QuitNestedMessageLoop,
                  base::Unretained(this),
                  run_loop->QuitClosure());
   *run_closure = base::Bind(&NestedAcceleratorController::RunNestedMessageLoop,
                             base::Unretained(this),
                             base::Passed(&run_loop),
                             base::Passed(&old_accelerator_dispatcher));
 }
 
 void NestedAcceleratorController::RunNestedMessageLoop(
     scoped_ptr<base::RunLoop> run_loop,
     scoped_ptr<NestedAcceleratorDispatcher> old_accelerator_dispatcher) {
   run_loop->Run();
-  accelerator_dispatcher_ = old_accelerator_dispatcher.Pass();
+  accelerator_dispatcher_ = std::move(old_accelerator_dispatcher);
 }
 
 void NestedAcceleratorController::QuitNestedMessageLoop(
     const base::Closure& quit_runloop) {
   quit_runloop.Run();
   accelerator_dispatcher_.reset();
 }
 
 }  // namespace wm