Use std::move() instead of .Pass() in remoting/*

remoting/client/software_video_renderer_unittest.cc

 // Copyright 2015 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 "remoting/client/software_video_renderer.h"
 
 #include <stdint.h>
 
+#include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/threading/thread.h"
 #include "remoting/client/frame_consumer.h"
 #include "remoting/codec/video_encoder_verbatim.h"
 #include "remoting/proto/video.pb.h"
 #include "remoting/protocol/session_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
 
 using webrtc::DesktopFrame;
 
 namespace remoting {
 
 namespace {
 
 const int kFrameWidth = 200;
 const int kFrameHeight = 200;
 
 class TestFrameConsumer : public FrameConsumer {
  public:
   TestFrameConsumer() {}
   ~TestFrameConsumer() override {}
 
-  scoped_ptr<DesktopFrame> WaitForNextFrame(
-      base::Closure* out_done_callback) {
+  scoped_ptr<DesktopFrame> WaitForNextFrame(base::Closure* out_done_callback) {
     EXPECT_TRUE(thread_checker_.CalledOnValidThread());
     frame_run_loop_.reset(new base::RunLoop());
     frame_run_loop_->Run();
     frame_run_loop_.reset();
     *out_done_callback = last_frame_done_callback_;
     last_frame_done_callback_.Reset();
-    return last_frame_.Pass();
+    return std::move(last_frame_);
   }
 
   // FrameConsumer interface.
   scoped_ptr<DesktopFrame> AllocateFrame(
       const webrtc::DesktopSize& size) override {
     EXPECT_TRUE(thread_checker_.CalledOnValidThread());
     return make_scoped_ptr(new webrtc::BasicDesktopFrame(size));
   }
 
   void DrawFrame(scoped_ptr<DesktopFrame> frame,
                  const base::Closure& done) override {
     EXPECT_TRUE(thread_checker_.CalledOnValidThread());
-    last_frame_ = frame.Pass();
+    last_frame_ = std::move(frame);
     last_frame_done_callback_ = done;
     frame_run_loop_->Quit();
   }
 
   PixelFormat GetPixelFormat() override {
     EXPECT_TRUE(thread_checker_.CalledOnValidThread());
     return FORMAT_BGRA;
   }
 
  private:
@@ skipping 21 matching lines @@
   }
 
   if (index == 0) {
     frame->mutable_updated_region()->SetRect(
         webrtc::DesktopRect::MakeWH(kFrameWidth, kFrameHeight));
   } else {
     frame->mutable_updated_region()->SetRect(
         webrtc::DesktopRect::MakeWH(index, index));
   }
 
-  return frame.Pass();
+  return frame;
 }
 
 // Returns true when frames a and b are equivalent.
 bool CompareFrames(const DesktopFrame& a, const DesktopFrame& b) {
   if (!a.size().equals(b.size()) ||
       !a.updated_region().Equals(b.updated_region())) {
     return false;
   }
 
   for (webrtc::DesktopRegion::Iterator i(a.updated_region()); !i.IsAtEnd();
@@ skipping 64 matching lines @@
 
     EXPECT_FALSE(callback_called[frame_index]);
     done_callback.Run();
     EXPECT_TRUE(callback_called[frame_index]);
 
     EXPECT_TRUE(CompareFrames(*test_frames[frame_index], *decoded_frame));
   }
 }
 
 }  // namespace remoting