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

remoting/host/desktop_capturer_proxy.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/host/desktop_capturer_proxy.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 22 matching lines @@
 
   void CreateCapturer(const webrtc::DesktopCaptureOptions& options);
 
   void Start();
   void SetSharedMemoryFactory(
       std::unique_ptr<webrtc::SharedMemoryFactory> shared_memory_factory);
   void Capture(const webrtc::DesktopRegion& rect);
 
  private:
   // webrtc::DesktopCapturer::Callback implementation.
-  void OnCaptureCompleted(webrtc::DesktopFrame* frame) override;
+  void OnCaptureResult(webrtc::DesktopCapturer::Result result,
+                       std::unique_ptr<webrtc::DesktopFrame> frame) override;
 
   base::ThreadChecker thread_checker_;
 
   base::WeakPtr<DesktopCapturerProxy> proxy_;
   scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner_;
   std::unique_ptr<webrtc::DesktopCapturer> capturer_;
 
   DISALLOW_COPY_AND_ASSIGN(Core);
 };
 
@@ skipping 32 matching lines @@
   if (capturer_) {
     capturer_->SetSharedMemoryFactory(std::move(shared_memory_factory));
   }
 }
 
 void DesktopCapturerProxy::Core::Capture(const webrtc::DesktopRegion& rect) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (capturer_) {
     capturer_->Capture(rect);
   } else {
-    OnCaptureCompleted(nullptr);
+    OnCaptureResult(webrtc::DesktopCapturer::Result::ERROR_PERMANENT, nullptr);
   }
 }
 
-void DesktopCapturerProxy::Core::OnCaptureCompleted(
-    webrtc::DesktopFrame* frame) {
+void DesktopCapturerProxy::Core::OnCaptureResult(
+    webrtc::DesktopCapturer::Result result,
+    std::unique_ptr<webrtc::DesktopFrame> frame) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   caller_task_runner_->PostTask(
       FROM_HERE, base::Bind(&DesktopCapturerProxy::OnFrameCaptured, proxy_,
-                            base::Passed(base::WrapUnique(frame))));
+                            result, base::Passed(&frame)));
 }
 
 DesktopCapturerProxy::DesktopCapturerProxy(
     scoped_refptr<base::SingleThreadTaskRunner> capture_task_runner,
     const webrtc::DesktopCaptureOptions& options)
     : capture_task_runner_(capture_task_runner), weak_factory_(this) {
   core_.reset(new Core(weak_factory_.GetWeakPtr()));
   capture_task_runner_->PostTask(
       FROM_HERE, base::Bind(&Core::CreateCapturer,
                             base::Unretained(core_.get()), options));
@@ skipping 28 matching lines @@
 
   // Start() must be called before Capture().
   DCHECK(callback_);
 
   capture_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&Core::Capture, base::Unretained(core_.get()), rect));
 }
 
 void DesktopCapturerProxy::OnFrameCaptured(
+    webrtc::DesktopCapturer::Result result,
     std::unique_ptr<webrtc::DesktopFrame> frame) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  callback_->OnCaptureCompleted(frame.release());
+  callback_->OnCaptureResult(result, std::move(frame));
 }
 
 }  // namespace remoting