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

remoting/host/desktop_session_proxy.cc

 // Copyright (c) 2012 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_session_proxy.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 160 matching lines @@
   }
 }
 
 bool DesktopSessionProxy::OnMessageReceived(const IPC::Message& message) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(DesktopSessionProxy, message)
     IPC_MESSAGE_HANDLER(ChromotingDesktopNetworkMsg_AudioPacket,
                         OnAudioPacket)
-    IPC_MESSAGE_HANDLER(ChromotingDesktopNetworkMsg_CaptureCompleted,
-                        OnCaptureCompleted)
+    IPC_MESSAGE_HANDLER(ChromotingDesktopNetworkMsg_CaptureResult,
+                        OnCaptureResult)
     IPC_MESSAGE_HANDLER(ChromotingDesktopNetworkMsg_MouseCursor,
                         OnMouseCursor)
     IPC_MESSAGE_HANDLER(ChromotingDesktopNetworkMsg_CreateSharedBuffer,
                         OnCreateSharedBuffer)
     IPC_MESSAGE_HANDLER(ChromotingDesktopNetworkMsg_ReleaseSharedBuffer,
                         OnReleaseSharedBuffer)
     IPC_MESSAGE_HANDLER(ChromotingDesktopNetworkMsg_InjectClipboardEvent,
                         OnInjectClipboardEvent)
     IPC_MESSAGE_HANDLER(ChromotingDesktopNetworkMsg_DisconnectSession,
                         DisconnectSession);
@@ skipping 62 matching lines @@
   desktop_channel_.reset();
 
   if (desktop_process_.IsValid())
     desktop_process_.Close();
 
   shared_buffers_.clear();
 
   // Generate fake responses to keep the video capturer in sync.
   while (pending_capture_frame_requests_) {
     --pending_capture_frame_requests_;
-    video_capturer_->OnCaptureCompleted(nullptr);
+    video_capturer_->OnCaptureResult(
+        webrtc::DesktopCapturer::Result::ERROR_PERMANENT, nullptr);
   }
 }
 
 void DesktopSessionProxy::SetAudioCapturer(
     const base::WeakPtr<IpcAudioCapturer>& audio_capturer) {
   DCHECK(audio_capture_task_runner_->BelongsToCurrentThread());
 
   audio_capturer_ = audio_capturer;
 }
 
 void DesktopSessionProxy::CaptureFrame() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   if (desktop_channel_) {
     ++pending_capture_frame_requests_;
     SendToDesktop(new ChromotingNetworkDesktopMsg_CaptureFrame());
   } else {
-    video_capturer_->OnCaptureCompleted(nullptr);
+    video_capturer_->OnCaptureResult(
+        webrtc::DesktopCapturer::Result::ERROR_PERMANENT, nullptr);
   }
 }
 
 void DesktopSessionProxy::SetVideoCapturer(
     const base::WeakPtr<IpcVideoFrameCapturer> video_capturer) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   video_capturer_ = video_capturer;
 }
 
@@ skipping 166 matching lines @@
   }
 }
 
 void DesktopSessionProxy::OnReleaseSharedBuffer(int id) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   // Drop the cached reference to the buffer.
   shared_buffers_.erase(id);
 }
 
-void DesktopSessionProxy::OnCaptureCompleted(
+void DesktopSessionProxy::OnCaptureResult(
+    webrtc::DesktopCapturer::Result result,
     const SerializedDesktopFrame& serialized_frame) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   --pending_capture_frame_requests_;
 
-  // If the input serialized_frame does not have a screen size, it means the
-  // capturer returns a nullptr for OnCaptureCompleted call.
-  if (serialized_frame.dimensions.is_empty()) {
-    video_capturer_->OnCaptureCompleted(nullptr);
+  if (result != webrtc::DesktopCapturer::Result::SUCCESS) {
+    video_capturer_->OnCaptureResult(result, nullptr);
     return;
   }
 
   // Assume that |serialized_frame| is well-formed because it was received from
   // a more privileged process.
   scoped_refptr<IpcSharedBufferCore> shared_buffer_core =
       GetSharedBufferCore(serialized_frame.shared_buffer_id);
   CHECK(shared_buffer_core.get());
 
   std::unique_ptr<webrtc::DesktopFrame> frame(
       new webrtc::SharedMemoryDesktopFrame(
           serialized_frame.dimensions, serialized_frame.bytes_per_row,
           new IpcSharedBuffer(shared_buffer_core)));
   frame->set_capture_time_ms(serialized_frame.capture_time_ms);
   frame->set_dpi(serialized_frame.dpi);
 
-  for (size_t i = 0; i < serialized_frame.dirty_region.size(); ++i) {
-    frame->mutable_updated_region()->AddRect(serialized_frame.dirty_region[i]);
+  for (auto& rect : serialized_frame.dirty_region) {

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

s/auto/const auto/?

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

Done.

+    frame->mutable_updated_region()->AddRect(rect);
   }
 
-  video_capturer_->OnCaptureCompleted(std::move(frame));
+  video_capturer_->OnCaptureResult(webrtc::DesktopCapturer::Result::SUCCESS,
+                                   std::move(frame));
 }
 
 void DesktopSessionProxy::OnMouseCursor(
     const webrtc::MouseCursor& mouse_cursor) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   if (mouse_cursor_monitor_) {
     mouse_cursor_monitor_->OnMouseCursor(
         base::WrapUnique(webrtc::MouseCursor::CopyOf(mouse_cursor)));
   }
@@ skipping 25 matching lines @@
 }
 
 // static
 void DesktopSessionProxyTraits::Destruct(
     const DesktopSessionProxy* desktop_session_proxy) {
   desktop_session_proxy->caller_task_runner_->DeleteSoon(FROM_HERE,
                                                          desktop_session_proxy);
 }
 
 }  // namespace remoting