[Chromoting] Let the Windows IT2Me host send clipboard events to the client.

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"
 #include "remoting/proto/control.pb.h"
 #include "remoting/proto/event.pb.h"
 #include "remoting/protocol/client_stub.h"
 
 namespace remoting {
 
 ClientSession::ClientSession(
     EventHandler* event_handler,
     scoped_ptr<protocol::ConnectionToClient> connection,
     protocol::HostEventStub* host_event_stub,
     Capturer* capturer)
     : event_handler_(event_handler),
       connection_(connection.Pass()),
       client_jid_(connection_->session()->jid()),
       is_authenticated_(false),
       host_event_stub_(host_event_stub),
       input_tracker_(host_event_stub_),
       remote_input_filter_(&input_tracker_),
       mouse_input_filter_(&remote_input_filter_),
+      client_clipboard_(clipboard_echo_filter_.client_filter()),
       capturer_(capturer) {
   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);
   clipboard_echo_filter_.set_host_stub(host_event_stub_);
@@ skipping 117 matching lines @@
   DCHECK(CalledOnValidThread());
 
   if (disable_inputs) {
     disable_input_filter_.set_input_stub(NULL);
     input_tracker_.ReleaseAll();
   } else {
     disable_input_filter_.set_input_stub(&mouse_input_filter_);
   }
 }
 
+scoped_refptr<protocol::ClipboardProxy> ClientSession::ClientClipboard() {
+  DCHECK(CalledOnValidThread());
+
+  scoped_refptr<protocol::ClipboardProxy> client_clipboard =
+      new protocol::ClipboardProxy(base::MessageLoopProxy::current());
+  client_clipboard->Attach(client_clipboard_.AsWeakPtr());
+  return client_clipboard;

[Wez, 2012/05/30 01:15:43]

Since you're creating a new ClipboardProxy every time ClientClipboard gets
called, there's no real benefit in it being refcounted.

[simonmorris, 2012/05/30 16:54:06]

I want ClipboardThreadProxy to be refcounted so that it can safely post messages
to itself on another thread.

[Wez, 2012/05/30 17:07:47]

You can do that if instead of storing a WeakPtr to the target ClipboardStub in
the ClipboardThreadProxy, you store a WeakPtr to the ClipboardThreadProxy
itself.  Any tasks it posts to itself will be dropped by the task queue if they
are processed after the proxy('s WeakPtrFactory) has been deleted.

(The caller must then guarantee that the ClipboardStub outlive the
ClipboardThreadProxy, but that should be easy enough to arrange.)

[simonmorris, 2012/05/30 23:18:26]

As discussed offline, ClipboardThreadProxy does need to outlive ClipboardStub,
but WeakPtr can be used instead of ref-counting anyway.

+}
+
 }  // namespace remoting