Interface with webrtc through encoded frames

remoting/host/video_frame_recorder.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 "remoting/host/video_frame_recorder.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 25 matching lines @@
 
   void set_enable_recording(bool enable_recording) {
     DCHECK(!encoder_task_runner_.get() ||
            encoder_task_runner_->BelongsToCurrentThread());
     enable_recording_ = enable_recording;
   }
 
   // remoting::VideoEncoder interface.
   void SetLosslessEncode(bool want_lossless) override;
   void SetLosslessColor(bool want_lossless) override;
-  scoped_ptr<VideoPacket> Encode(const webrtc::DesktopFrame& frame) override;
+  scoped_ptr<VideoPacket> Encode(const webrtc::DesktopFrame& frame,
+                                 uint32_t flags = 0) override;
 
  private:
   scoped_ptr<VideoEncoder> encoder_;
   scoped_refptr<base::TaskRunner> recorder_task_runner_;
   base::WeakPtr<VideoFrameRecorder> recorder_;
 
   bool enable_recording_;
   scoped_refptr<base::SingleThreadTaskRunner> encoder_task_runner_;
 
   base::WeakPtrFactory<RecordingVideoEncoder> weak_factory_;
@@ skipping 23 matching lines @@
     bool want_lossless) {
   encoder_->SetLosslessEncode(want_lossless);
 }
 
 void VideoFrameRecorder::RecordingVideoEncoder::SetLosslessColor(
     bool want_lossless) {
   encoder_->SetLosslessColor(want_lossless);
 }
 
 scoped_ptr<VideoPacket> VideoFrameRecorder::RecordingVideoEncoder::Encode(
-    const webrtc::DesktopFrame& frame) {
+    const webrtc::DesktopFrame& frame,
+    uint32_t flags) {
   // If this is the first Encode() then store the TaskRunner and inform the
   // VideoFrameRecorder so it can post set_enable_recording() on it.
   if (!encoder_task_runner_.get()) {
     encoder_task_runner_ = base::ThreadTaskRunnerHandle::Get();
     recorder_task_runner_->PostTask(FROM_HERE,
         base::Bind(&VideoFrameRecorder::SetEncoderTaskRunner,
                    recorder_,
                    encoder_task_runner_));
   }
 
   DCHECK(encoder_task_runner_->BelongsToCurrentThread());
 
   if (enable_recording_) {
     // Copy the frame and post it to the VideoFrameRecorder to store.
     scoped_ptr<webrtc::DesktopFrame> frame_copy(
         new webrtc::BasicDesktopFrame(frame.size()));
     *frame_copy->mutable_updated_region() = frame.updated_region();
     frame_copy->set_dpi(frame.dpi());
     frame_copy->CopyPixelsFrom(frame.data(),
                                frame.stride(),
                                webrtc::DesktopRect::MakeSize(frame.size()));
     recorder_task_runner_->PostTask(FROM_HERE,
         base::Bind(&VideoFrameRecorder::RecordFrame,
                    recorder_,
                    base::Passed(&frame_copy)));
   }
 
-  return encoder_->Encode(frame);
+  return encoder_->Encode(frame, flags);
 }
 
 VideoFrameRecorder::VideoFrameRecorder()
     : content_bytes_(0),
       max_content_bytes_(0),
       enable_recording_(false),
       weak_factory_(this) {
 }
 
 VideoFrameRecorder::~VideoFrameRecorder() {
@@ skipping 113 matching lines @@
   if (content_bytes_ + frame_bytes > max_content_bytes_) {
     return;
   }
 
   // Store the frame and update the content byte count.
   recorded_frames_.push_back(frame.release());
   content_bytes_ += frame_bytes;
 }
 
 }  // namespace remoting