[Mojo Video Capture] Replace const scoped_refptr<T>& with scoped_refptr<T> and use std::move

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 <memory>
 #include <utility>
@@ skipping 150 matching lines @@
   const base::TimeTicks refresh_time = base::TimeTicks::Now();
 
   scoped_refptr<VideoFrame> frame;
   CaptureFrameCallback capture_callback;
   if (!ObserveEventAndDecideCapture(VideoCaptureOracle::kPassiveRefreshRequest,
                                     gfx::Rect(), refresh_time, &frame,
                                     &capture_callback)) {
     return false;
   }
 
-  capture_callback.Run(frame, refresh_time, true);
+  capture_callback.Run(std::move(frame), refresh_time, true);
   return true;
 }
 
 gfx::Size ThreadSafeCaptureOracle::GetCaptureSize() const {
   base::AutoLock guard(lock_);
   return oracle_.capture_size();
 }
 
 void ThreadSafeCaptureOracle::UpdateCaptureSize(const gfx::Size& source_size) {
   base::AutoLock guard(lock_);
@@ skipping 12 matching lines @@
   base::AutoLock guard(lock_);
   if (client_)
     client_->OnError(from_here, reason);
 }
 
 void ThreadSafeCaptureOracle::DidCaptureFrame(
     int frame_number,
     std::unique_ptr<VideoCaptureDevice::Client::Buffer> buffer,
     base::TimeTicks capture_begin_time,
     base::TimeDelta estimated_frame_duration,
-    const scoped_refptr<VideoFrame>& frame,
+    scoped_refptr<VideoFrame> frame,
     base::TimeTicks reference_time,
     bool success) {
   TRACE_EVENT_ASYNC_END2("gpu.capture", "Capture", buffer.get(), "success",
                          success, "timestamp",
                          reference_time.ToInternalValue());
 
   base::AutoLock guard(lock_);
 
   if (oracle_.CompleteCapture(frame_number, success, &reference_time)) {
     TRACE_EVENT_INSTANT0("gpu.capture", "CaptureSucceeded",
@@ skipping 10 matching lines @@
                                     base::TimeTicks::Now());
     frame->metadata()->SetTimeDelta(VideoFrameMetadata::FRAME_DURATION,
                                     estimated_frame_duration);
     frame->metadata()->SetTimeTicks(VideoFrameMetadata::REFERENCE_TIME,
                                     reference_time);
 
     frame->AddDestructionObserver(
         base::Bind(&ThreadSafeCaptureOracle::DidConsumeFrame, this,
                    frame_number, frame->metadata()));
 
-    client_->OnIncomingCapturedVideoFrame(std::move(buffer), frame);
+    client_->OnIncomingCapturedVideoFrame(std::move(buffer), std::move(frame));
   }
 }
 
 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