Add WebrtcCaptureScheduler interface.

remoting/protocol/webrtc_dummy_video_encoder.cc

 // Copyright 2016 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/protocol/webrtc_dummy_video_encoder.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/callback.h"
@@ skipping 76 matching lines @@
   VLOG(1) << "WebrtcDummyVideoEncoder::SetRates bitrate:framerate " << bitrate
           << ":" << framerate;
   if (!target_bitrate_cb_.is_null())
     target_bitrate_cb_.Run(bitrate);
   // framerate is not expected to be valid given we never report captured
   // frames
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 webrtc::EncodedImageCallback::Result WebrtcDummyVideoEncoder::SendEncodedFrame(
-    std::unique_ptr<WebrtcVideoEncoder::EncodedFrame> frame,
+    const WebrtcVideoEncoder::EncodedFrame& frame,
     base::TimeTicks capture_time) {
   uint8_t* buffer =
-      reinterpret_cast<uint8_t*>(const_cast<char*>(frame->data.data()));
-  size_t buffer_size = frame->data.size();
+      reinterpret_cast<uint8_t*>(const_cast<char*>(frame.data.data()));
+  size_t buffer_size = frame.data.size();
   base::AutoLock lock(lock_);
   if (state_ == kUninitialized) {
     LOG(ERROR) << "encoder interface uninitialized";
     return webrtc::EncodedImageCallback::Result(
         webrtc::EncodedImageCallback::Result::ERROR_SEND_FAILED);
   }
 
   webrtc::EncodedImage encoded_image(buffer, buffer_size, buffer_size);
-  encoded_image._encodedWidth = frame->size.width();
-  encoded_image._encodedHeight = frame->size.height();
+  encoded_image._encodedWidth = frame.size.width();
+  encoded_image._encodedHeight = frame.size.height();
   encoded_image._completeFrame = true;
   encoded_image._frameType =
-      frame->key_frame ? webrtc::kVideoFrameKey : webrtc::kVideoFrameDelta;
+      frame.key_frame ? webrtc::kVideoFrameKey : webrtc::kVideoFrameDelta;
   int64_t capture_time_ms = (capture_time - base::TimeTicks()).InMilliseconds();
   encoded_image.capture_time_ms_ = capture_time_ms;
   encoded_image._timeStamp = static_cast<uint32_t>(capture_time_ms * 90);
   encoded_image.playout_delay_.min_ms = 0;
   encoded_image.playout_delay_.max_ms = 0;
 
   webrtc::CodecSpecificInfo codec_specific_info;
   memset(&codec_specific_info, 0, sizeof(codec_specific_info));
   codec_specific_info.codecType = webrtc::kVideoCodecVP8;
 
@@ skipping 74 matching lines @@
     if ((*pos).get() == encoder) {
       encoders_.erase(pos);
       return;
     }
   }
   DCHECK(false) << "Asked to remove encoder not owned by factory";
 }
 
 webrtc::EncodedImageCallback::Result
 WebrtcDummyVideoEncoderFactory::SendEncodedFrame(
-    std::unique_ptr<WebrtcVideoEncoder::EncodedFrame> frame,
+    const WebrtcVideoEncoder::EncodedFrame& frame,
     base::TimeTicks capture_time) {
   if (encoders_.size() != 1) {
     LOG(ERROR) << "Unexpected number of encoders " << encoders_.size();
     return webrtc::EncodedImageCallback::Result(
         webrtc::EncodedImageCallback::Result::ERROR_SEND_FAILED);
   }
-  return encoders_.front()->SendEncodedFrame(std::move(frame), capture_time);
+  return encoders_.front()->SendEncodedFrame(frame, capture_time);
 }
 
 void WebrtcDummyVideoEncoderFactory::SetKeyFrameRequestCallback(
     const base::Closure& key_frame_request) {
   base::AutoLock lock(lock_);
   key_frame_request_ = key_frame_request;
   if (encoders_.size() == 1) {
     encoders_.front()->SetKeyFrameRequestCallback(key_frame_request);
   } else {
     LOG(ERROR) << "Dropping key frame request callback with unexpected"
@@ skipping 10 matching lines @@
     encoders_.front()->SetTargetBitrateCallback(target_bitrate_cb);
   } else {
     LOG(ERROR) << "Dropping target bitrate request callback with unexpected"
                   " number of encoders: "
                << encoders_.size();
   }
 }
 
 }  // namespace protocol
 }  // namespace remoting