Convert Pass()→std::move() in //media

media/capture/content/thread_safe_capture_oracle.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 "media/capture/content/thread_safe_capture_oracle.h"
 
 #include <stdint.h>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/bits.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/synchronization/lock.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "media/base/video_capture_types.h"
 #include "media/base/video_frame.h"
@@ skipping 10 matching lines @@
 // VideoCaptureOracle.  This value takes into account the maximum number of
 // buffer pool buffers and a desired safety margin.
 const int kTargetMaxPoolUtilizationPercent = 60;
 
 }  // namespace
 
 ThreadSafeCaptureOracle::ThreadSafeCaptureOracle(
     scoped_ptr<VideoCaptureDevice::Client> client,
     const VideoCaptureParams& params,
     bool enable_auto_throttling)
-    : client_(client.Pass()),
+    : client_(std::move(client)),
       oracle_(base::TimeDelta::FromMicroseconds(static_cast<int64_t>(
                   1000000.0 / params.requested_format.frame_rate +
                   0.5 /* to round to nearest int */)),
               params.requested_format.frame_size,
               params.resolution_change_policy,
               enable_auto_throttling),
       params_(params) {}
 
 ThreadSafeCaptureOracle::~ThreadSafeCaptureOracle() {
 }
@@ skipping 129 matching lines @@
                                     capture_begin_time);
     frame->metadata()->SetTimeTicks(VideoFrameMetadata::CAPTURE_END_TIME,
                                     base::TimeTicks::Now());
     frame->metadata()->SetTimeDelta(VideoFrameMetadata::FRAME_DURATION,
                                     estimated_frame_duration);
 
     frame->AddDestructionObserver(
         base::Bind(&ThreadSafeCaptureOracle::DidConsumeFrame, this,
                    frame_number, frame->metadata()));
 
-    client_->OnIncomingCapturedVideoFrame(buffer.Pass(), frame, timestamp);
+    client_->OnIncomingCapturedVideoFrame(std::move(buffer), frame, timestamp);
   }
 }
 
 void ThreadSafeCaptureOracle::DidConsumeFrame(
     int frame_number,
     const media::VideoFrameMetadata* metadata) {
   // Note: This function may be called on any thread by the VideoFrame
   // destructor.  |metadata| is still valid for read-access at this point.
   double utilization = -1.0;
   if (metadata->GetDouble(media::VideoFrameMetadata::RESOURCE_UTILIZATION,
                           &utilization)) {
     base::AutoLock guard(lock_);
     oracle_.RecordConsumerFeedback(frame_number, utilization);
   }
 }
 
 }  // namespace media