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

remoting/client/plugin/pepper_video_renderer_3d.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 "remoting/client/plugin/pepper_video_renderer_3d.h"
 
 #include <math.h>
 
+#include <utility>
+
 #include "base/callback_helpers.h"
 #include "base/stl_util.h"
 #include "ppapi/c/pp_codecs.h"
 #include "ppapi/c/ppb_opengles2.h"
 #include "ppapi/c/ppb_video_decoder.h"
 #include "ppapi/cpp/instance.h"
 #include "ppapi/lib/gl/include/GLES2/gl2.h"
 #include "ppapi/lib/gl/include/GLES2/gl2ext.h"
 #include "remoting/proto/video.pb.h"
 #include "remoting/protocol/performance_tracker.h"
 #include "remoting/protocol/session_config.h"
 
 namespace remoting {
 
 // The implementation here requires that the decoder allocates at least 3
 // pictures. PPB_VideoDecoder didn't support this parameter prior to
 // 1.1, so we have to pass 0 for backwards compatibility with older versions of
 // the browser. Currently all API implementations allocate more than 3 buffers
 // by default.
 //
 // TODO(sergeyu): Change this to 3 once PPB_VideoDecoder v1.1 is enabled on
 // stable channel (crbug.com/520323).
 const uint32_t kMinimumPictureCount = 0;  // 3
 
 class PepperVideoRenderer3D::PendingPacket {
  public:
   PendingPacket(scoped_ptr<VideoPacket> packet, const base::Closure& done)
-      : packet_(packet.Pass()),
-        done_runner_(done) {
-  }
+      : packet_(std::move(packet)), done_runner_(done) {}
 
   ~PendingPacket() {}
 
   const VideoPacket* packet() const { return packet_.get(); }
 
  private:
   scoped_ptr<VideoPacket> packet_;
   base::ScopedClosureRunner done_runner_;
 };
 
@@ skipping 168 matching lines @@
   if (packet->has_use_desktop_shape()) {
     if (packet->use_desktop_shape()) {
       scoped_ptr<webrtc::DesktopRegion> shape(new webrtc::DesktopRegion);
       for (int i = 0; i < packet->desktop_shape_rects_size(); ++i) {
         Rect remoting_rect = packet->desktop_shape_rects(i);
         shape->AddRect(webrtc::DesktopRect::MakeXYWH(
             remoting_rect.x(), remoting_rect.y(), remoting_rect.width(),
             remoting_rect.height()));
       }
       if (!frame_shape_ || !frame_shape_->Equals(*shape)) {
-        frame_shape_ = shape.Pass();
+        frame_shape_ = std::move(shape);
         event_handler_->OnVideoShape(frame_shape_.get());
       }
     } else if (frame_shape_) {
       frame_shape_ = nullptr;
       event_handler_->OnVideoShape(nullptr);
     }
   }
 
   // Report the dirty region, for debugging, if requested.
   if (debug_dirty_region_) {
     webrtc::DesktopRegion dirty_region;
     for (int i = 0; i < packet->dirty_rects_size(); ++i) {
       Rect remoting_rect = packet->dirty_rects(i);
       dirty_region.AddRect(webrtc::DesktopRect::MakeXYWH(
           remoting_rect.x(), remoting_rect.y(),
           remoting_rect.width(), remoting_rect.height()));
     }
     event_handler_->OnVideoFrameDirtyRegion(dirty_region);
   }
 
   pending_packets_.push_back(
-      new PendingPacket(packet.Pass(), done_runner.Release()));
+      new PendingPacket(std::move(packet), done_runner.Release()));
   DecodeNextPacket();
 }
 
 void PepperVideoRenderer3D::OnInitialized(int32_t result) {
   // Assume that VP8 and VP9 codecs are always supported by the browser.
   CHECK_EQ(result, PP_OK) << "VideoDecoder::Initialize() failed: " << result;
   initialization_finished_ = true;
 
   // Start decoding in case a frame was received during decoder initialization.
   DecodeNextPacket();
@@ skipping 73 matching lines @@
   PaintIfNeeded();
   GetNextPicture();
 }
 
 void PepperVideoRenderer3D::PaintIfNeeded() {
   bool need_repaint = next_picture_ || (force_repaint_ && current_picture_);
   if (paint_pending_ || !need_repaint)
     return;
 
   if (next_picture_)
-    current_picture_ = next_picture_.Pass();
+    current_picture_ = std::move(next_picture_);
 
   force_repaint_ = false;
 
   const PP_VideoPicture& picture = current_picture_->picture();
   PP_Resource graphics_3d = graphics_.pp_resource();
 
   EnsureProgramForTexture(picture.texture_target);
 
   gles2_if_->UseProgram(graphics_3d, shader_program_);
 
@@ skipping 163 matching lines @@
   gles2_if_->AttachShader(graphics_.pp_resource(), shader_program_, shader);
   gles2_if_->DeleteShader(graphics_.pp_resource(), shader);
 }
 
 void PepperVideoRenderer3D::CheckGLError() {
   GLenum error = gles2_if_->GetError(graphics_.pp_resource());
   CHECK_EQ(error, static_cast<GLenum>(GL_NO_ERROR)) << "GL error: " << error;
 }
 
 }  // namespace remoting