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

remoting/protocol/webrtc_frame_scheduler.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_frame_scheduler.h"
 
 #include <algorithm>
 #include <memory>
 
 #include "base/location.h"
@@ skipping 107 matching lines @@
   target_bitrate_kbps_ = target_bitrate_kbps;
 }
 
 bool WebRtcFrameScheduler::ClearAndGetKeyFrameRequest() {
   base::AutoLock lock(lock_);
   bool key_frame_request = key_frame_request_;
   key_frame_request_ = false;
   return key_frame_request;
 }
 
-void WebRtcFrameScheduler::OnCaptureCompleted(webrtc::DesktopFrame* frame) {
+void WebRtcFrameScheduler::OnCaptureResult(
+    webrtc::DesktopCapturer::Result result,
+    std::unique_ptr<webrtc::DesktopFrame> frame) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   base::TimeTicks captured_ticks = base::TimeTicks::Now();
   int64_t capture_timestamp_ms =
       (captured_ticks - base::TimeTicks()).InMilliseconds();
   capture_pending_ = false;
 
-  std::unique_ptr<webrtc::DesktopFrame> owned_frame(frame);
+  // TODO(sergeyu): Handle ERROR_PERMANENT result here.
 
   if (encode_pending_) {
     // TODO(isheriff): consider queuing here
     VLOG(1) << "Dropping captured frame since encoder is still busy";
     return;
   }
 
   // If unchanged and does not need top-off, return.
   if (!frame || (frame->updated_region().is_empty() &&
                  last_quantizer_ <= kTargetQuantizerForTopOff)) {
     return;
   }
 
   last_capture_completed_ticks_ = captured_ticks;
 
   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_);
   }
   encode_pending_ = true;
   task_tracker_.PostTaskAndReplyWithResult(
       encode_task_runner_.get(), FROM_HERE,
       base::Bind(&WebRtcFrameScheduler::EncodeFrame, encoder_.get(),
-                 base::Passed(std::move(owned_frame)), target_bitrate_kbps_,
+                 base::Passed(&frame), target_bitrate_kbps_,
                  ClearAndGetKeyFrameRequest(), capture_timestamp_ms),
       base::Bind(&WebRtcFrameScheduler::OnFrameEncoded,
                  weak_factory_.GetWeakPtr()));
 }
 
 void WebRtcFrameScheduler::CaptureNextFrame() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (capture_pending_ || encode_pending_) {
     VLOG(1) << "Capture/encode still pending..";
@@ skipping 56 matching lines @@
   } else {
     LOG(ERROR) << "SendEncodedFrame() failed";
   }
   capture_timer_->Start(FROM_HERE,
                         base::TimeDelta::FromMilliseconds(next_sched_ms), this,
                         &WebRtcFrameScheduler::CaptureNextFrame);
 }
 
 }  // namespace protocol
 }  // namespace remoting