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

remoting/codec/codec_test.cc

 // Copyright (c) 2012 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 <stddef.h>
 #include <stdint.h>
 #include <stdlib.h>
+
 #include <deque>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "media/base/video_frame.h"
 #include "remoting/base/util.h"
 #include "remoting/codec/codec_test.h"
 #include "remoting/codec/video_decoder.h"
 #include "remoting/codec/video_encoder.h"
@@ skipping 158 matching lines @@
   VideoEncoderTester() : decoder_tester_(nullptr), data_available_(0) {}
 
   ~VideoEncoderTester() {
     EXPECT_GT(data_available_, 0);
   }
 
   void DataAvailable(scoped_ptr<VideoPacket> packet) {
     ++data_available_;
     // Send the message to the VideoDecoderTester.
     if (decoder_tester_) {
-      decoder_tester_->ReceivedPacket(packet.Pass());
+      decoder_tester_->ReceivedPacket(std::move(packet));
     }
   }
 
   void set_decoder_tester(VideoDecoderTester* decoder_tester) {
     decoder_tester_ = decoder_tester;
   }
 
  private:
   VideoDecoderTester* decoder_tester_;
   int data_available_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoEncoderTester);
 };
 
 scoped_ptr<DesktopFrame> PrepareFrame(const DesktopSize& size) {
   scoped_ptr<DesktopFrame> frame(new BasicDesktopFrame(size));
 
   srand(0);
   int memory_size = size.width() * size.height() * kBytesPerPixel;
   for (int i = 0; i < memory_size; ++i) {
     frame->data()[i] = rand() % 256;
   }
 
-  return frame.Pass();
+  return frame;
 }
 
 static void TestEncodingRects(VideoEncoder* encoder,
                               VideoEncoderTester* tester,
                               DesktopFrame* frame,
                               const DesktopRegion& region) {
   *frame->mutable_updated_region() = region;
-  scoped_ptr<VideoPacket> packet = encoder->Encode(*frame);
-  tester->DataAvailable(packet.Pass());
+  tester->DataAvailable(encoder->Encode(*frame));
 }
 
 void TestVideoEncoder(VideoEncoder* encoder, bool strict) {
   const int kSizes[] = {80, 79, 77, 54};
 
   VideoEncoderTester tester;
 
   for (size_t xi = 0; xi < arraysize(kSizes); ++xi) {
     for (size_t yi = 0; yi < arraysize(kSizes); ++yi) {
       DesktopSize size(kSizes[xi], kSizes[yi]);
@@ skipping 48 matching lines @@
     const int row_size = DesktopFrame::kBytesPerPixel * i.rect().width();
     uint8_t* memory = frame->data() + frame->stride() * i.rect().top() +
                     DesktopFrame::kBytesPerPixel * i.rect().left();
     for (int y = 0; y < i.rect().height(); ++y) {
       for (int x = 0; x < row_size; ++x)
         memory[x] = rand() % 256;
       memory += frame->stride();
     }
   }
 
-  scoped_ptr<VideoPacket> packet = encoder->Encode(*frame);
-  encoder_tester->DataAvailable(packet.Pass());
+  encoder_tester->DataAvailable(encoder->Encode(*frame));
   decoder_tester->VerifyResults();
   decoder_tester->Reset();
 }
 
 void TestVideoEncoderDecoder(VideoEncoder* encoder,
                              VideoDecoder* decoder,
                              bool strict) {
   DesktopSize kSize = DesktopSize(160, 120);
 
   VideoEncoderTester encoder_tester;
@@ skipping 30 matching lines @@
                                      double max_error_limit,
                                      double mean_error_limit) {
   scoped_ptr<BasicDesktopFrame> frame(
       new BasicDesktopFrame(screen_size));
   FillWithGradient(frame.get());
   frame->mutable_updated_region()->SetRect(DesktopRect::MakeSize(screen_size));
 
   VideoDecoderTester decoder_tester(decoder, screen_size);
   decoder_tester.set_expected_frame(frame.get());
   decoder_tester.AddRegion(frame->updated_region());
-
-  scoped_ptr<VideoPacket> packet = encoder->Encode(*frame);
-  decoder_tester.ReceivedPacket(packet.Pass());
+  decoder_tester.ReceivedPacket(encoder->Encode(*frame));
 
   decoder_tester.VerifyResultsApprox(max_error_limit, mean_error_limit);
 }
 
 float MeasureVideoEncoderFpsWithSize(VideoEncoder* encoder,
                                      const DesktopSize& size) {
   scoped_ptr<DesktopFrame> frame(PrepareFrame(size));
   frame->mutable_updated_region()->SetRect(DesktopRect::MakeSize(size));
   std::list<DesktopFrame*> frames;
   frames.push_back(frame.get());
@@ skipping 29 matching lines @@
 
     if (frame_count >= kWarmUpFrameCount) {
       elapsed = base::TimeTicks::Now() - start_time;
     }
   }
 
   return (frame_count * base::TimeDelta::FromSeconds(1)) / elapsed;
 }
 
 }  // namespace remoting