Use IpcVideoFrameCapturer on network thread instead of capturer thread.

remoting/host/desktop_session_agent.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_agent.h"
 
 #include <utility>
 
 #include "base/files/file_util.h"
 #include "base/logging.h"
@@ skipping 140 matching lines @@
 };
 
 }  // namespace
 
 DesktopSessionAgent::Delegate::~Delegate() {}
 
 DesktopSessionAgent::DesktopSessionAgent(
     scoped_refptr<AutoThreadTaskRunner> audio_capture_task_runner,
     scoped_refptr<AutoThreadTaskRunner> caller_task_runner,
     scoped_refptr<AutoThreadTaskRunner> input_task_runner,
-    scoped_refptr<AutoThreadTaskRunner> io_task_runner,
-    scoped_refptr<AutoThreadTaskRunner> video_capture_task_runner)
+    scoped_refptr<AutoThreadTaskRunner> io_task_runner)
     : audio_capture_task_runner_(audio_capture_task_runner),
       caller_task_runner_(caller_task_runner),
       input_task_runner_(input_task_runner),
       io_task_runner_(io_task_runner),
-      video_capture_task_runner_(video_capture_task_runner),
       weak_factory_(this) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 }
 
 bool DesktopSessionAgent::OnMessageReceived(const IPC::Message& message) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   bool handled = true;
   if (started_) {
     IPC_BEGIN_MESSAGE_MAP(DesktopSessionAgent, message)
@@ skipping 130 matching lines @@
 
   // Start the audio capturer.
   if (delegate_->desktop_environment_factory().SupportsAudioCapture()) {
     audio_capturer_ = desktop_environment_->CreateAudioCapturer();
     audio_capture_task_runner_->PostTask(
         FROM_HERE, base::Bind(&DesktopSessionAgent::StartAudioCapturer, this));
   }
 
   // Start the video capturer and mouse cursor monitor.
   video_capturer_ = desktop_environment_->CreateVideoCapturer();
+  video_capturer_->Start(this);
+  video_capturer_->SetSharedMemoryFactory(
+      rtc_make_scoped_ptr(new SharedMemoryFactoryImpl(
+          base::Bind(&DesktopSessionAgent::SendToNetwork, this))));
   mouse_cursor_monitor_ = desktop_environment_->CreateMouseCursorMonitor();
-  video_capture_task_runner_->PostTask(
-      FROM_HERE, base::Bind(
-          &DesktopSessionAgent::StartVideoCapturerAndMouseMonitor, this));
+  mouse_cursor_monitor_->Init(this, webrtc::MouseCursorMonitor::SHAPE_ONLY);
 }
 
 void DesktopSessionAgent::OnCaptureCompleted(webrtc::DesktopFrame* frame) {
-  DCHECK(video_capture_task_runner_->BelongsToCurrentThread());
+  DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   last_frame_.reset(frame);
 
   current_size_ = frame->size();
 
   // Serialize webrtc::DesktopFrame.
   SerializedDesktopFrame serialized_frame;
   serialized_frame.shared_buffer_id = frame->shared_memory()->id();
   serialized_frame.bytes_per_row = frame->stride();
   serialized_frame.dimensions = frame->size();
   serialized_frame.capture_time_ms = frame->capture_time_ms();
   serialized_frame.dpi = frame->dpi();
   for (webrtc::DesktopRegion::Iterator i(frame->updated_region());
        !i.IsAtEnd(); i.Advance()) {
     serialized_frame.dirty_region.push_back(i.rect());
   }
 
   SendToNetwork(make_scoped_ptr(
       new ChromotingDesktopNetworkMsg_CaptureCompleted(serialized_frame)));
 }
 
 void DesktopSessionAgent::OnMouseCursor(webrtc::MouseCursor* cursor) {
-  DCHECK(video_capture_task_runner_->BelongsToCurrentThread());
+  DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   scoped_ptr<webrtc::MouseCursor> owned_cursor(cursor);
 
   SendToNetwork(make_scoped_ptr(
       new ChromotingDesktopNetworkMsg_MouseCursor(*owned_cursor)));
 }
 
 void DesktopSessionAgent::OnMouseCursorPosition(
     webrtc::MouseCursorMonitor::CursorState state,
     const webrtc::DesktopVector& position) {
@@ skipping 74 matching lines @@
 
     desktop_environment_.reset();
     input_injector_.reset();
     screen_controls_.reset();
 
     // Stop the audio capturer.
     audio_capture_task_runner_->PostTask(
         FROM_HERE, base::Bind(&DesktopSessionAgent::StopAudioCapturer, this));
 
     // Stop the video capturer.
-    video_capture_task_runner_->PostTask(
-        FROM_HERE, base::Bind(
-            &DesktopSessionAgent::StopVideoCapturerAndMouseMonitor, this));
+    video_capturer_.reset();
+    last_frame_.reset();
+    mouse_cursor_monitor_.reset();
   }
 }
 
 void DesktopSessionAgent::OnCaptureFrame() {
-  if (!video_capture_task_runner_->BelongsToCurrentThread()) {
-    video_capture_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(&DesktopSessionAgent::OnCaptureFrame, this));
-    return;
-  }
+  DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   mouse_cursor_monitor_->Capture();
 
   // webrtc::DesktopCapturer supports a very few (currently 2) outstanding
   // capture requests. The requests are serialized on
   // |video_capture_task_runner()| task runner. If the client issues more
   // requests, pixel data in captured frames will likely be corrupted but
   // stability of webrtc::DesktopCapturer will not be affected.
   video_capturer_->Capture(webrtc::DesktopRegion());
 }
@@ skipping 110 matching lines @@
                                       this));
   }
 }
 
 void DesktopSessionAgent::StopAudioCapturer() {
   DCHECK(audio_capture_task_runner_->BelongsToCurrentThread());
 
   audio_capturer_.reset();
 }
 
-void DesktopSessionAgent::StartVideoCapturerAndMouseMonitor() {
-  DCHECK(video_capture_task_runner_->BelongsToCurrentThread());
-
-  if (video_capturer_) {
-    video_capturer_->Start(this);
-    video_capturer_->SetSharedMemoryFactory(
-        rtc_make_scoped_ptr(new SharedMemoryFactoryImpl(
-            base::Bind(&DesktopSessionAgent::SendToNetwork, this))));
-  }
-
-  if (mouse_cursor_monitor_) {
-    mouse_cursor_monitor_->Init(this, webrtc::MouseCursorMonitor::SHAPE_ONLY);
-  }
-}
-
-void DesktopSessionAgent::StopVideoCapturerAndMouseMonitor() {
-  DCHECK(video_capture_task_runner_->BelongsToCurrentThread());
-
-  video_capturer_.reset();
-  last_frame_.reset();
-  mouse_cursor_monitor_.reset();
-}
-
 }  // namespace remoting