Added support of Secure Attention Sequence in multiprocess mode.

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"
@@ skipping 42 matching lines @@
 DesktopSesssionClipboardStub::~DesktopSesssionClipboardStub() {
 }
 
 void DesktopSesssionClipboardStub::InjectClipboardEvent(
     const protocol::ClipboardEvent& event) {
   desktop_session_agent_->InjectClipboardEvent(event);
 }
 
 }  // namespace
 
+DesktopSessionAgent::Delegate::~Delegate() {
+}
+
 DesktopSessionAgent::~DesktopSessionAgent() {
   DCHECK(!network_channel_);
   DCHECK(!video_capturer_);
 }
 
 bool DesktopSessionAgent::OnMessageReceived(const IPC::Message& message) {
   DCHECK(caller_task_runner()->BelongsToCurrentThread());
 
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(DesktopSessionAgent, message)
@@ skipping 20 matching lines @@
   VLOG(1) << "IPC: desktop <- network (" << peer_pid << ")";
 }
 
 void DesktopSessionAgent::OnChannelError() {
   DCHECK(caller_task_runner()->BelongsToCurrentThread());
 
   // Make sure the channel is closed.
   network_channel_.reset();
 
   // Notify the caller that the channel has been disconnected.
-  disconnected_task_.Run();
+  delegate_->OnNetworkProcessDisconnected();
 }
 
 scoped_refptr<SharedBuffer> DesktopSessionAgent::CreateSharedBuffer(
     uint32 size) {
   DCHECK(video_capture_task_runner()->BelongsToCurrentThread());
 
   scoped_refptr<SharedBuffer> buffer = new SharedBuffer(size);
   if (buffer->ptr() != NULL) {
     buffer->set_id(next_shared_buffer_id_);
     shared_buffers_.push_back(buffer);
@@ skipping 67 matching lines @@
   std::string serialized_event;
   if (!event.SerializeToString(&serialized_event)) {
     LOG(ERROR) << "Failed to serialize protocol::ClipboardEvent.";
     return;
   }
 
   SendToNetwork(
       new ChromotingDesktopNetworkMsg_InjectClipboardEvent(serialized_event));
 }
 
-bool DesktopSessionAgent::Start(const base::Closure& disconnected_task,
+bool DesktopSessionAgent::Start(Delegate* delegate,
                                 IPC::PlatformFileForTransit* desktop_pipe_out) {
   DCHECK(caller_task_runner()->BelongsToCurrentThread());
+  DCHECK(delegate_ == NULL);
 
-  disconnected_task_ = disconnected_task;
+  delegate_ = delegate;
 
   // Create an IPC channel to communicate with the network process.
   if (!CreateChannelForNetworkProcess(desktop_pipe_out, &network_channel_))
     return false;
 
   // Create and start the event executor.
-  event_executor_ = EventExecutor::Create(input_task_runner(),
-                                          caller_task_runner());
+  event_executor_ = CreateEventExecutor();
   scoped_ptr<protocol::ClipboardStub> clipboard_stub(
       new DesktopSesssionClipboardStub(this));
   event_executor_->Start(clipboard_stub.Pass());
 
   // Start the video capturer.
   video_capture_task_runner()->PostTask(
       FROM_HERE, base::Bind(&DesktopSessionAgent::StartVideoCapturer, this));
   return true;
 }
 
 void DesktopSessionAgent::Stop() {
   DCHECK(caller_task_runner()->BelongsToCurrentThread());
 
+  delegate_ = NULL;
+
   // Make sure the channel is closed.
   network_channel_.reset();
 
   event_executor_.reset();
 
   // Stop the video capturer.
   video_capture_task_runner()->PostTask(
       FROM_HERE, base::Bind(&DesktopSessionAgent::StopVideoCapturer, this));
 }
 
@@ skipping 165 matching lines @@
 
 DesktopSessionAgent::DesktopSessionAgent(
     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)
     : 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),
+      delegate_(NULL),
       next_shared_buffer_id_(1) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 }
 
 }  // namespace remoting