Add the plumbing that will carry a clipboard item from a chromoting client to a host.

remoting/host/client_session.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/client_session.h"
 
 #include <algorithm>
 
 #include "base/message_loop_proxy.h"
 #include "remoting/host/capturer.h"
@@ skipping 10 matching lines @@
 static const int64 kRemoteBlockTimeoutMillis = 2000;
 
 namespace remoting {
 
 using protocol::KeyEvent;
 using protocol::MouseEvent;
 
 ClientSession::ClientSession(
     EventHandler* event_handler,
     protocol::ConnectionToClient* connection,
-    protocol::InputStub* input_stub,
+    protocol::HostEventStub* host_event_stub,
     Capturer* capturer)
     : event_handler_(event_handler),
       connection_(connection),
       client_jid_(connection->session()->jid()),
-      input_stub_(input_stub),
+      host_event_stub_(host_event_stub),
       capturer_(capturer),
       authenticated_(false),
       awaiting_continue_approval_(false),
       remote_mouse_button_state_(0) {
   connection_->SetEventHandler(this);
 
   // TODO(sergeyu): Currently ConnectionToClient expects stubs to be
   // set before channels are connected. Make it possible to set stubs
   // later and set them only when connection is authenticated.
+  connection_->set_clipboard_stub(this);
   connection_->set_host_stub(this);
   connection_->set_input_stub(this);
 }
 
 ClientSession::~ClientSession() {
 }
 
+void ClientSession::InjectClipboardEvent(
+    const protocol::ClipboardEvent& event) {
+  DCHECK(CalledOnValidThread());
+
+  if (authenticated_) {
+    host_event_stub_->InjectClipboardEvent(event);
+  }
+}
+
 void ClientSession::InjectKeyEvent(const KeyEvent& event) {
   DCHECK(CalledOnValidThread());
 
   if (authenticated_ && !ShouldIgnoreRemoteKeyboardInput(event)) {
     RecordKeyEvent(event);
-    input_stub_->InjectKeyEvent(event);
+    host_event_stub_->InjectKeyEvent(event);
   }
 }
 
 void ClientSession::InjectMouseEvent(const MouseEvent& event) {
   DCHECK(CalledOnValidThread());
 
   if (authenticated_ && !ShouldIgnoreRemoteMouseInput(event)) {
     RecordMouseButtonState(event);
     MouseEvent event_to_inject = event;
     if (event.has_x() && event.has_y()) {
@@ skipping 12 matching lines @@
       // fake mouse button events. Note that we need to do this after we
       // clamp the values to the screen area.
       remote_mouse_pos_ = pos;
 
       injected_mouse_positions_.push_back(pos);
       if (injected_mouse_positions_.size() > kNumRemoteMousePositions) {
         VLOG(1) << "Injected mouse positions queue full.";
         injected_mouse_positions_.pop_front();
       }
     }
-    input_stub_->InjectMouseEvent(event_to_inject);
+    host_event_stub_->InjectMouseEvent(event_to_inject);
   }
 }
 
 void ClientSession::OnConnectionOpened(
     protocol::ConnectionToClient* connection) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(connection_.get(), connection);
   authenticated_ = true;
   event_handler_->OnSessionAuthenticated(this);
 }
@@ skipping 133 matching lines @@
 
 void ClientSession::RestoreEventState() {
   DCHECK(CalledOnValidThread());
 
   // Undo any currently pressed keys.
   std::set<int>::iterator i;
   for (i = pressed_keys_.begin(); i != pressed_keys_.end(); ++i) {
     KeyEvent key;
     key.set_keycode(*i);
     key.set_pressed(false);
-    input_stub_->InjectKeyEvent(key);
+    host_event_stub_->InjectKeyEvent(key);
   }
   pressed_keys_.clear();
 
   // Undo any currently pressed mouse buttons.
   for (int i = 1; i < MouseEvent::BUTTON_MAX; i++) {
     if (remote_mouse_button_state_ & (1 << (i - 1))) {
       MouseEvent mouse;
       // TODO(wez): Shouldn't [need to] set position here.
       mouse.set_x(remote_mouse_pos_.x());
       mouse.set_y(remote_mouse_pos_.y());
       mouse.set_button((MouseEvent::MouseButton)i);
       mouse.set_button_down(false);
-      input_stub_->InjectMouseEvent(mouse);
+      host_event_stub_->InjectMouseEvent(mouse);
     }
   }
   remote_mouse_button_state_ = 0;
 }
 
 }  // namespace remoting