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

remoting/test/test_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/test/test_video_renderer.h"
 
 #include <stdint.h>
 
 #include <cmath>
+#include <utility>
 
 #include "base/macros.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/timer/timer.h"
 #include "remoting/codec/video_encoder.h"
 #include "remoting/codec/video_encoder_verbatim.h"
 #include "remoting/codec/video_encoder_vpx.h"
@@ skipping 123 matching lines @@
   DCHECK(!timer_->IsRunning());
   run_loop_.reset(new base::RunLoop());
 
   // Set an extremely long time: 10 min to prevent bugs from hanging the system.
   // NOTE: We've seen cases which take up to 1 min to process a packet, so an
   // extremely long time as 10 min is chosen to avoid being variable/flaky.
   timer_->Start(FROM_HERE, base::TimeDelta::FromMinutes(10),
                 run_loop_->QuitClosure());
 
   // Wait for the video packet to be processed and rendered to buffer.
-  test_video_renderer_->ProcessVideoPacket(packet.Pass(),
+  test_video_renderer_->ProcessVideoPacket(std::move(packet),
                                            run_loop_->QuitClosure());
 
   run_loop_->Run();
   EXPECT_TRUE(timer_->IsRunning());
   timer_->Stop();
   run_loop_.reset();
 
   scoped_ptr<webrtc::DesktopFrame> buffer_copy =
       test_video_renderer_->GetCurrentFrameForTest();
   EXPECT_NE(buffer_copy, nullptr);
@@ skipping 19 matching lines @@
                 run_loop_->QuitClosure());
 
   // Set expected image pattern.
   test_video_renderer_->ExpectAverageColorInRect(
       expected_rect, expected_average_color, run_loop_->QuitClosure());
 
   // Used to verify if the expected image pattern will be matched by |packet|.
   scoped_ptr<VideoPacket> packet_copy(new VideoPacket(*packet.get()));
 
   // Post first test packet: |packet|.
-  test_video_renderer_->ProcessVideoPacket(packet.Pass(),
+  test_video_renderer_->ProcessVideoPacket(std::move(packet),
                                            base::Bind(&base::DoNothing));
 
   // Second packet: |packet_copy| is posted, and |second_packet_done_callback|
   // will always be posted back to main thread, however, whether it will be
   // called depends on whether the expected pattern is matched or not.
   bool second_packet_done_is_called = false;
   base::Closure second_packet_done_callback =
       base::Bind(&ProcessPacketDoneHandler, run_loop_->QuitClosure(),
                  &second_packet_done_is_called);
 
-  test_video_renderer_->ProcessVideoPacket(packet_copy.Pass(),
+  test_video_renderer_->ProcessVideoPacket(std::move(packet_copy),
                                            second_packet_done_callback);
 
   run_loop_->Run();
   EXPECT_TRUE(timer_->IsRunning());
   timer_->Stop();
   run_loop_.reset();
 
   // if expected image pattern is matched, the QuitClosure of |run_loop_| will
   // be called before |second_packet_done_callback|, which leaves
   // |second_packet_done_is_called| be false.
@@ skipping 10 matching lines @@
   DCHECK(encoder_);
   DCHECK(test_video_renderer_);
 
   scoped_ptr<webrtc::DesktopFrame> frame =
       CreateDesktopFrameWithGradient(screen_width, screen_height);
   RGBValue expected_average_color =
       CalculateAverageColorValueForFrame(frame.get(), expected_rect);
   scoped_ptr<VideoPacket> packet = encoder_->Encode(*frame.get());
 
   if (expect_to_match) {
-    EXPECT_TRUE(SendPacketAndWaitForMatch(packet.Pass(), expected_rect,
+    EXPECT_TRUE(SendPacketAndWaitForMatch(std::move(packet), expected_rect,
                                           expected_average_color));
   } else {
     // Shift each channel by 128.
     // e.g. (10, 127, 200) -> (138, 255, 73).
     // In this way, the error between expected color and true value is always
     // around 0.5.
     int red_shift = (expected_average_color.red + 128) % 255;
     int green_shift = (expected_average_color.green + 128) % 255;
     int blue_shift = (expected_average_color.blue + 128) % 255;
 
     RGBValue expected_average_color_shift =
         RGBValue(red_shift, green_shift, blue_shift);
 
-    EXPECT_FALSE(SendPacketAndWaitForMatch(packet.Pass(), expected_rect,
+    EXPECT_FALSE(SendPacketAndWaitForMatch(std::move(packet), expected_rect,
                                            expected_average_color_shift));
   }
 }
 
 RGBValue TestVideoRendererTest::CalculateAverageColorValueForFrame(
     const webrtc::DesktopFrame* frame,
     const webrtc::DesktopRect& rect) const {
   int red_sum = 0;
   int green_sum = 0;
   int blue_sum = 0;
@@ skipping 73 matching lines @@
 
 scoped_ptr<webrtc::DesktopFrame>
     TestVideoRendererTest::CreateDesktopFrameWithGradient(
         int screen_width, int screen_height) const {
   webrtc::DesktopSize screen_size(screen_width, screen_height);
   scoped_ptr<webrtc::DesktopFrame> frame(
       new webrtc::BasicDesktopFrame(screen_size));
   frame->mutable_updated_region()->SetRect(
       webrtc::DesktopRect::MakeSize(screen_size));
   FillFrameWithGradient(frame.get());
-  return frame.Pass();
+  return frame;
 }
 
 void TestVideoRendererTest::FillFrameWithGradient(
     webrtc::DesktopFrame* frame) const {
   for (int y = 0; y < frame->size().height(); ++y) {
     uint8_t* p = frame->data() + y * frame->stride();
     for (int x = 0; x < frame->size().width(); ++x) {
       *p++ = (255.0 * x) / frame->size().width();
       *p++ = (164.0 * y) / frame->size().height();
       *p++ = (82.0 * (x + y)) /
@@ skipping 89 matching lines @@
 
   // Since we don't care whether expected image pattern is matched or not in
   // this case, an expected color is chosen arbitrarily.
   RGBValue black_color = RGBValue();
 
   // Set expected image pattern.
   test_video_renderer_->ExpectAverageColorInRect(
       kDefaultExpectedRect, black_color, base::Bind(&base::DoNothing));
 
   // Post test video packet.
-  scoped_ptr<VideoPacket> packet = encoder_->Encode(*frame.get());
-  test_video_renderer_->ProcessVideoPacket(packet.Pass(),
+  test_video_renderer_->ProcessVideoPacket(encoder_->Encode(*frame.get()),
                                            base::Bind(&base::DoNothing));
 }
 
 // Verify correct image pattern can be matched for VP8.
 TEST_F(TestVideoRendererTest, VerifyImagePatternMatchForVP8) {
   encoder_ = VideoEncoderVpx::CreateForVP8();
   test_video_renderer_->SetCodecForDecoding(
       protocol::ChannelConfig::Codec::CODEC_VP8);
   TestImagePatternMatch(kDefaultScreenWidthPx, kDefaultScreenHeightPx,
                         kDefaultExpectedRect, true);
@@ skipping 39 matching lines @@
 TEST_F(TestVideoRendererTest, VerifyImagePatternNotMatchForVERBATIM) {
   encoder_.reset(new VideoEncoderVerbatim());
   test_video_renderer_->SetCodecForDecoding(
       protocol::ChannelConfig::Codec::CODEC_VERBATIM);
   TestImagePatternMatch(kDefaultScreenWidthPx, kDefaultScreenHeightPx,
                         kDefaultExpectedRect, false);
 }
 
 }  // namespace test
 }  // namespace remoting