DesktopSessionAgent now hosts the video capturer and provides necessary plumbing to drive it via an…

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 "base/logging.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_message_macros.h"
 #include "remoting/base/auto_thread_task_runner.h"
+#include "remoting/base/capture_data.h"
 #include "remoting/host/chromoting_messages.h"
+#include "remoting/proto/control.pb.h"
 
 namespace remoting {
 
 DesktopSessionAgent::~DesktopSessionAgent() {
-  DCHECK(caller_task_runner()->BelongsToCurrentThread());
+  DCHECK(!video_capturer_);
 }
 
 bool DesktopSessionAgent::OnMessageReceived(const IPC::Message& message) {
   DCHECK(caller_task_runner()->BelongsToCurrentThread());
 
-  NOTIMPLEMENTED();
-  return false;
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP(DesktopSessionAgent, message)
+    IPC_MESSAGE_HANDLER(ChromotingNetworkDesktopMsg_CaptureFrame,
+                        OnCaptureFrame)
+    IPC_MESSAGE_HANDLER(ChromotingNetworkDesktopMsg_InvalidateRegion,
+                        OnInvalidateRegion)
+    IPC_MESSAGE_HANDLER(ChromotingNetworkDesktopMsg_SharedBufferRegistered,
+                        OnSharedBufferRegistered)
+  IPC_END_MESSAGE_MAP()
+  return handled;
 }
 
 void DesktopSessionAgent::OnChannelConnected(int32 peer_pid) {
   DCHECK(caller_task_runner()->BelongsToCurrentThread());
 
   VLOG(1) << "IPC: desktop <- network (" << peer_pid << ")";
-
-  NOTIMPLEMENTED();
 }
 
 void DesktopSessionAgent::OnChannelError() {
   DCHECK(caller_task_runner()->BelongsToCurrentThread());
 
   // Make sure the channel is closed.
   network_channel_.reset();
 
   // Notify the caller that |this| can be destroyed now.
   done_task_.Run();
 }
 
+void DesktopSessionAgent::RegisterSharedBuffer(
+    scoped_refptr<SharedBuffer> buffer) {
+  DCHECK(video_capture_task_runner()->BelongsToCurrentThread());
+  DCHECK(buffer->id() == 0);
+
+  // Use buffer's address as its ID.

[Wez, 2012/11/16 23:37:31]

Do we care that that discloses information about the agent's memory layout to a
potentially less privileged process?

[alexeypa (please no reviews), 2012/11/19 21:46:25]

I don't see how it can be exploited.

+  buffer->set_id(reinterpret_cast<intptr_t>(buffer.get()));
+  shared_buffers_.push_back(buffer);
+
+  SendToNetwork(new ChromotingDesktopNetworkMsg_RegisterSharedBuffer(
+      buffer->id(), buffer->handle(), buffer->size()));
+}
+
+void DesktopSessionAgent::DropSharedBuffer(intptr_t id) {
+  DCHECK(video_capture_task_runner()->BelongsToCurrentThread());
+  DCHECK(id != 0);
+
+  SendToNetwork(new ChromotingDesktopNetworkMsg_DropSharedBuffer(id));
+}
+
+void DesktopSessionAgent::OnCaptureCompleted(
+    scoped_refptr<CaptureData> capture_data) {
+  DCHECK(video_capture_task_runner()->BelongsToCurrentThread());
+
+  // Serialize CaptureData
+  SerializedCapturedData serialized_data;
+  serialized_data.shared_buffer_id = capture_data->shared_buffer()->id();
+  serialized_data.dimensions = capture_data->size();
+  serialized_data.pixel_format = capture_data->pixel_format();
+  serialized_data.capture_time_ms = capture_data->capture_time_ms();
+  serialized_data.client_sequence_number =
+      capture_data->client_sequence_number();
+  serialized_data.dpi = capture_data->dpi();
+  for (SkRegion::Iterator i(capture_data->dirty_region()); !i.done(); i.next())
+    serialized_data.dirty_region.push_back(i.rect());
+
+  SendToNetwork(
+      new ChromotingDesktopNetworkMsg_CaptureCompleted(serialized_data));
+}
+
+void DesktopSessionAgent::OnCursorShapeChanged(
+    scoped_ptr<protocol::CursorShapeInfo> cursor_shape) {
+  DCHECK(video_capture_task_runner()->BelongsToCurrentThread());
+
+  NOTIMPLEMENTED();
+}
+
 bool DesktopSessionAgent::Start(const base::Closure& done_task,
                                 IPC::PlatformFileForTransit* desktop_pipe_out) {
   DCHECK(caller_task_runner()->BelongsToCurrentThread());
 
   done_task_ = done_task;
-  return DoCreateNetworkChannel(desktop_pipe_out, &network_channel_);
+  if (!DoCreateNetworkChannel(desktop_pipe_out, &network_channel_))
+    return false;
+
+  // Start the video capturer.
+  video_capture_task_runner()->PostTask(
+      FROM_HERE, base::Bind(&DesktopSessionAgent::StartVideoCapturer, this));
+  return true;
+}
+
+void DesktopSessionAgent::Stop() {

[Wez, 2012/11/16 23:37:31]

Thread check?

[alexeypa (please no reviews), 2012/11/19 21:46:25]

Done.

+  // Stop the video capturer.
+  video_capture_task_runner()->PostTask(
+      FROM_HERE, base::Bind(&DesktopSessionAgent::StopVideoCapturer, this));
+}
+
+void DesktopSessionAgent::InvalidateRegion(
+    scoped_ptr<SkRegion> invalid_region) {
+  DCHECK(video_capture_task_runner()->BelongsToCurrentThread());
+
+  video_capturer_->InvalidateRegion(*invalid_region);
+}
+
+void DesktopSessionAgent::OnCaptureFrame() {
+  if (!video_capture_task_runner()->BelongsToCurrentThread()) {
+    video_capture_task_runner()->PostTask(
+        FROM_HERE,
+        base::Bind(&DesktopSessionAgent::OnCaptureFrame, this));
+    return;
+  }
+
+  video_capturer_->CaptureInvalidRegion();
+}
+
+void DesktopSessionAgent::OnInvalidateRegion(
+    const std::vector<SkIRect>& invalid_region) {

[Wez, 2012/11/16 23:37:31]

nit: invalid_rects or region_rects

[alexeypa (please no reviews), 2012/11/19 21:46:25]

Done.

+  DCHECK(caller_task_runner()->BelongsToCurrentThread());
+
+  scoped_ptr<SkRegion> region(new SkRegion());
+  region->setRects(&invalid_region[0], invalid_region.size());
+
+  video_capture_task_runner()->PostTask(
+      FROM_HERE, base::Bind(&DesktopSessionAgent::InvalidateRegion, this,
+                            base::Passed(&region)));

[Wez, 2012/11/16 23:37:31]

Hmmmm; this is the sort of glue I'd hoped to avoid, by having the caller call
VideoFrameCapturer on whatever thread they like, and have the capturer switch to
the capture thread, and back, if necessary.

[alexeypa (please no reviews), 2012/11/19 21:46:25]

VideoFrameCapturer is designed to run on a single thread. This CL is not a good
place to change that.

+}
+
+void DesktopSessionAgent::OnSharedBufferRegistered(intptr_t id) {
+  if (!video_capture_task_runner()->BelongsToCurrentThread()) {
+    video_capture_task_runner()->PostTask(
+        FROM_HERE,
+        base::Bind(&DesktopSessionAgent::OnSharedBufferRegistered, this, id));
+    return;
+  }
+
+  // Drop the cached reference to the buffer.
+  SharedBuffers::iterator i = shared_buffers_.begin();
+  for (; i != shared_buffers_.end(); ++i) {
+    if ((*i)->id() == id) {
+      shared_buffers_.erase(i);
+      break;
+    }
+  }
+}
+
+void DesktopSessionAgent::SendToNetwork(IPC::Message* message) {

[Wez, 2012/11/16 23:37:31]

nit: SendIpcToNetwork?

[alexeypa (please no reviews), 2012/11/19 21:46:25]

I don't think so:

1. There are other SendToXxx wrappers in the code base. SendIpcXxx will not be
consistent.
2. It is too verbose, especially because the compiler is checking the
parameter's type. 

+  if (!caller_task_runner()->BelongsToCurrentThread()) {
+    caller_task_runner()->PostTask(
+        FROM_HERE,
+        base::Bind(&DesktopSessionAgent::SendToNetwork, this, message));
+    return;
+  }
+
+  if (network_channel_) {
+    network_channel_->Send(message);
+  } else {
+    delete message;
+  }
+}
+
+void DesktopSessionAgent::StartVideoCapturer() {
+  DCHECK(video_capture_task_runner()->BelongsToCurrentThread());
+
+  video_capturer_.reset(VideoFrameCapturer::Create());
+  video_capturer_->UseSharedBuffers(this);
+  video_capturer_->Start(this);
+}
+
+void DesktopSessionAgent::StopVideoCapturer() {
+  DCHECK(video_capture_task_runner()->BelongsToCurrentThread());
+
+  video_capturer_->Stop();
+  video_capturer_->UseSharedBuffers(NULL);

[Wez, 2012/11/16 23:37:31]

Why do you need to NULL the buffer allocator / sender here?

[alexeypa (please no reviews), 2012/11/19 21:46:25]

Done.

+  video_capturer_.reset();
+
+  // Free any shared buffers left.
+  shared_buffers_.clear();
 }
 
 DesktopSessionAgent::DesktopSessionAgent(
     scoped_refptr<AutoThreadTaskRunner> caller_task_runner,
-    scoped_refptr<AutoThreadTaskRunner> io_task_runner)
+    scoped_refptr<AutoThreadTaskRunner> io_task_runner,
+    scoped_refptr<AutoThreadTaskRunner> video_capture_task_runner)
     : caller_task_runner_(caller_task_runner),
-      io_task_runner_(io_task_runner) {
+      io_task_runner_(io_task_runner),
+      video_capture_task_runner_(video_capture_task_runner) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 }
 
 }  // namespace remoting