Update webrtc::DesktopCapturer clients to implement OnCaptureResult().

remoting/protocol/video_frame_pump.cc

 // Copyright 2015 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/video_frame_pump.h"
 
 #include <algorithm>
 #include <memory>
 #include <utility>
 
@@ skipping 94 matching lines @@
   encode_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VideoEncoder::SetLosslessColor,
                             base::Unretained(encoder_.get()), want_lossless));
 }
 
 void VideoFramePump::SetSizeCallback(const SizeCallback& size_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   size_callback_ = size_callback;
 }
 
-void VideoFramePump::OnCaptureCompleted(webrtc::DesktopFrame* frame) {
+void VideoFramePump::OnCaptureResult(
+    webrtc::DesktopCapturer::Result result,
+    std::unique_ptr<webrtc::DesktopFrame> frame) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   capture_scheduler_.OnCaptureCompleted();
 
   captured_frame_timestamps_->capture_ended_time = base::TimeTicks::Now();
 
+  // TODO(sergeyu): Handle ERROR_PERMANENT result.

[Jamie, 2016/06/14 21:22:44]

Should this and similar TODOs have tracking bugs?

[Sergey Ulanov, 2016/06/15 20:30:10]

I removed the TODO in this file - it will be removed anyway in the future.
WebrtcFrameScheduler::OnCaptureResult() is the only place where this should be
fixed. I don't think it's worth opening a bug for it: it would be P3 anyway.
Also WebrtcFrameScheduler will need work and I'll probably address that TODO
there while making other changes.

+
   if (frame) {
     webrtc::DesktopVector dpi =
         frame->dpi().is_zero() ? webrtc::DesktopVector(kDefaultDpi, kDefaultDpi)
                                : frame->dpi();
     if (!frame_size_.equals(frame->size()) || !frame_dpi_.equals(dpi)) {
       frame_size_ = frame->size();
       frame_dpi_ = dpi;
       if (!size_callback_.is_null())
         size_callback_.Run(frame_size_, frame_dpi_);
     }
   }
 
   // Even when |frame| is nullptr we still need to post it to the encode thread
   // to make sure frames are freed in the same order they are received and
   // that we don't start capturing frame n+2 before frame n is freed.
   base::PostTaskAndReplyWithResult(
       encode_task_runner_.get(), FROM_HERE,
       base::Bind(&VideoFramePump::EncodeFrame, encoder_.get(),
-                 base::Passed(base::WrapUnique(frame)),
+                 base::Passed(&frame),
                  base::Passed(&captured_frame_timestamps_)),
       base::Bind(&VideoFramePump::OnFrameEncoded, weak_factory_.GetWeakPtr()));
 }
 
 void VideoFramePump::CaptureNextFrame() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // |next_frame_timestamps_| is not set if no input events were received since
   // the previous frame. In that case create FrameTimestamps instance without
   // setting |input_event_client_timestamp| and |input_event_received_time|.
@@ skipping 114 matching lines @@
 }
 
 void VideoFramePump::OnKeepAlivePacketSent() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   keep_alive_timer_.Reset();
 }
 
 }  // namespace protocol
 }  // namespace remoting