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

remoting/protocol/host_event_dispatcher.h

 // Copyright (c) 2011 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.
 
 #ifndef REMOTING_PROTOCOL_HOST_EVENT_DISPATCHER_H_
 #define REMOTING_PROTOCOL_HOST_EVENT_DISPATCHER_H_
 
 #include "remoting/protocol/channel_dispatcher_base.h"
 #include "remoting/protocol/message_reader.h"
 
 namespace remoting {
 namespace protocol {
 
+class ClipboardStub;
 class EventMessage;
 class InputStub;
 
 // HostEventDispatcher dispatches incoming messages on the event
-// channel to InputStub.
+// channel to InputStub or ClipboardStub.
 class HostEventDispatcher : public ChannelDispatcherBase {
  public:
   typedef base::Callback<void(int64)> SequenceNumberCallback;
 
   HostEventDispatcher();
   virtual ~HostEventDispatcher();
 
+  // Set the ClipboardStub that will be called for each incoming clipboard
+  // message. Doesn't take ownership of |clipboard_stub|. It must outlive
+  // the dispatcher.
+  void set_clipboard_stub(ClipboardStub* clipboard_stub) {

[Sergey Ulanov, 2012/03/09 00:23:41]

Would it be better to use control channel for clipboard. It will always be
reliable, while we may change event channel to be unreliable.

[simonmorris, 2012/03/09 00:34:14]

I think it's better to send clipboard events over the same channel as key and
mouse events, if only for consistency.

If the event channel becomes unreliable, presumably the key events (at least)
will move to a reliable channel, so the clipboard events could move at the same
time.

[Wez, 2012/03/09 00:44:07]

We'll have a keyboard-event-specific reliability protocol when we move to an
unreliable channel, so to get reliable clipboard transfer without building a
specialised reliability layer for it, we'll need to put clipboard data on a
separate channel, and used PseudoTcp for that.

+    clipboard_stub_ = clipboard_stub;
+  }
+
   // Set InputStub that will be called for each incoming input
   // message. Doesn't take ownership of |input_stub|. It must outlive
   // the dispatcher.
   void set_input_stub(InputStub* input_stub) { input_stub_ = input_stub; }
 
   // Set callback to notify of each message's sequence number. The
   // callback cannot tear down this object.
   void set_sequence_number_callback(const SequenceNumberCallback& value) {
     sequence_number_callback_ = value;
   }
 
  protected:
   // ChannelDispatcherBase overrides.
   virtual void OnInitialized() OVERRIDE;
 
  private:
   void OnMessageReceived(EventMessage* message,
                          const base::Closure& done_task);
 
+  ClipboardStub* clipboard_stub_;
   InputStub* input_stub_;
   SequenceNumberCallback sequence_number_callback_;
 
   ProtobufMessageReader<EventMessage> reader_;
 
   DISALLOW_COPY_AND_ASSIGN(HostEventDispatcher);
 };
 
 }  // namespace protocol
 }  // namespace remoting
 
 #endif  // REMOTING_PROTOCOL_HOST_EVENT_DISPATCHER_H_