Connect to DesktopEnvironment's stubs only when audio/video schedulers are about to be created.

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/capturer/video_frame_capturer.h"
@@ skipping 23 matching lines @@
     scoped_refptr<base::SingleThreadTaskRunner> video_encode_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> network_task_runner,
     scoped_ptr<protocol::ConnectionToClient> connection,
     DesktopEnvironmentFactory* desktop_environment_factory,
     const base::TimeDelta& max_duration)
     : event_handler_(event_handler),
       connection_(connection.Pass()),
       connection_factory_(connection_.get()),
       desktop_environment_(desktop_environment_factory->Create()),
       client_jid_(connection_->session()->jid()),
-      host_clipboard_stub_(desktop_environment_->event_executor()),
-      host_input_stub_(desktop_environment_->event_executor()),
-      input_tracker_(host_input_stub_),
+      input_tracker_(NULL),
       remote_input_filter_(&input_tracker_),
-      mouse_clamping_filter_(desktop_environment_->video_capturer(),
-                             &remote_input_filter_),
+      mouse_clamping_filter_(&remote_input_filter_, connection_->video_stub()),
       disable_input_filter_(&mouse_clamping_filter_),
       disable_clipboard_filter_(clipboard_echo_filter_.host_filter()),
       auth_input_filter_(&disable_input_filter_),
       auth_clipboard_filter_(&disable_clipboard_filter_),
       client_clipboard_factory_(clipboard_echo_filter_.client_filter()),
       max_duration_(max_duration),
       audio_task_runner_(audio_task_runner),
       video_capture_task_runner_(video_capture_task_runner),
       video_encode_task_runner_(video_encode_task_runner),
       network_task_runner_(network_task_runner),
       active_recorders_(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(&auth_clipboard_filter_);
   connection_->set_host_stub(this);
   connection_->set_input_stub(&auth_input_filter_);
-  clipboard_echo_filter_.set_host_stub(host_clipboard_stub_);
 
   // |auth_*_filter_|'s states reflect whether the session is authenticated.
   auth_input_filter_.set_enabled(false);
   auth_clipboard_filter_.set_enabled(false);
 }
 
 void ClientSession::NotifyClientDimensions(
     const protocol::ClientDimensions& dimensions) {
   if (dimensions.has_width() && dimensions.has_height()) {
     VLOG(1) << "Received ClientDimensions (width="
@@ skipping 40 matching lines @@
                               this, &ClientSession::Disconnect);
   }
 
   event_handler_->OnSessionAuthenticated(this);
 }
 
 void ClientSession::OnConnectionChannelsConnected(
     protocol::ConnectionToClient* connection) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(connection_.get(), connection);
+
+  // Attach the host clipboard and input stubs.

[Wez, 2013/01/08 18:34:00]

nit: Attach -> Connect

[alexeypa (please no reviews), 2013/01/08 20:00:14]

Done.

+  input_tracker_.set_input_stub(desktop_environment_->event_executor());
+  clipboard_echo_filter_.set_host_stub(desktop_environment_->event_executor());
+
   SetDisableInputs(false);
 
   // Let the desktop environment notify us of local clipboard changes.
   desktop_environment_->Start(
       CreateClipboardProxy(),
       client_jid(),
       base::Bind(&protocol::ConnectionToClient::Disconnect,
                  connection_factory_.GetWeakPtr()));
 
   // Create a VideoEncoder based on the session's video channel configuration.
   scoped_ptr<VideoEncoder> video_encoder =
       CreateVideoEncoder(connection_->session()->config());
 
   // Create a VideoScheduler to pump frames from the capturer to the client.
   video_scheduler_ = VideoScheduler::Create(
       video_capture_task_runner_,
       video_encode_task_runner_,
       network_task_runner_,
       desktop_environment_->video_capturer(),
       video_encoder.Pass(),
       connection_->client_stub(),
-      connection_->video_stub());
+      &mouse_clamping_filter_);
   ++active_recorders_;
 
   // Create an AudioScheduler if audio is enabled, to pump audio samples.
   if (connection_->session()->config().is_audio_enabled()) {
     scoped_ptr<AudioEncoder> audio_encoder =
         CreateAudioEncoder(connection_->session()->config());
     audio_scheduler_ = AudioScheduler::Create(
         audio_task_runner_,
         network_task_runner_,
         desktop_environment_->audio_capturer(),
@@ skipping 174 matching lines @@
   NOTIMPLEMENTED();
   return scoped_ptr<AudioEncoder>(NULL);
 }
 
 // static
 void ClientSessionTraits::Destruct(const ClientSession* client) {
   client->network_task_runner_->DeleteSoon(FROM_HERE, client);
 }
 
 }  // namespace remoting