Convert Pass()→std::move() in //content/browser

content/browser/media/capture/desktop_capture_device.cc

 // Copyright (c) 2013 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 "content/browser/media/capture/desktop_capture_device.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread.h"
 #include "base/timer/timer.h"
@@ skipping 113 matching lines @@
   scoped_ptr<PowerSaveBlocker> power_save_blocker_;
 
   DISALLOW_COPY_AND_ASSIGN(Core);
 };
 
 DesktopCaptureDevice::Core::Core(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     scoped_ptr<webrtc::DesktopCapturer> capturer,
     DesktopMediaID::Type type)
     : task_runner_(task_runner),
-      desktop_capturer_(capturer.Pass()),
+      desktop_capturer_(std::move(capturer)),
       capture_in_progress_(false),
       first_capture_returned_(false),
-      capturer_type_(type) {
-}
+      capturer_type_(type) {}
 
 DesktopCaptureDevice::Core::~Core() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   client_.reset();
   output_frame_.reset();
   previous_frame_size_.set(0, 0);
   desktop_capturer_.reset();
 }
 
 void DesktopCaptureDevice::Core::AllocateAndStart(
     const media::VideoCaptureParams& params,
     scoped_ptr<Client> client) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_GT(params.requested_format.frame_size.GetArea(), 0);
   DCHECK_GT(params.requested_format.frame_rate, 0);
   DCHECK(desktop_capturer_);
   DCHECK(client.get());
   DCHECK(!client_.get());
 
-  client_ = client.Pass();
+  client_ = std::move(client);
   requested_frame_rate_ = params.requested_format.frame_rate;
   resolution_chooser_.reset(new media::CaptureResolutionChooser(
       params.requested_format.frame_size,
       params.resolution_change_policy));
 
   power_save_blocker_.reset(
       PowerSaveBlocker::Create(
           PowerSaveBlocker::kPowerSaveBlockPreventDisplaySleep,
           PowerSaveBlocker::kReasonOther,
           "DesktopCaptureDevice is running").release());
@@ skipping 223 matching lines @@
       break;
     }
 
     default: {
       NOTREACHED();
     }
   }
 
   scoped_ptr<media::VideoCaptureDevice> result;
   if (capturer)
-    result.reset(new DesktopCaptureDevice(capturer.Pass(), source.type));
+    result.reset(new DesktopCaptureDevice(std::move(capturer), source.type));
 
-  return result.Pass();
+  return result;
 }
 
 DesktopCaptureDevice::~DesktopCaptureDevice() {
   DCHECK(!core_);
 }
 
 void DesktopCaptureDevice::AllocateAndStart(
     const media::VideoCaptureParams& params,
     scoped_ptr<Client> client) {
   thread_.task_runner()->PostTask(
@@ skipping 27 matching lines @@
     : thread_("desktopCaptureThread") {
 #if defined(OS_WIN)
   // On Windows the thread must be a UI thread.
   base::MessageLoop::Type thread_type = base::MessageLoop::TYPE_UI;
 #else
   base::MessageLoop::Type thread_type = base::MessageLoop::TYPE_DEFAULT;
 #endif
 
   thread_.StartWithOptions(base::Thread::Options(thread_type, 0));
 
-  core_.reset(new Core(thread_.task_runner(), capturer.Pass(), type));
+  core_.reset(new Core(thread_.task_runner(), std::move(capturer), type));
 }
 
 }  // namespace content