Tidy up ChromotingInstance members a little.

remoting/client/plugin/chromoting_instance.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/client/plugin/chromoting_instance.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 21 matching lines @@
 #include "remoting/client/chromoting_client.h"
 #include "remoting/client/frame_consumer_proxy.h"
 #include "remoting/client/plugin/pepper_audio_player.h"
 #include "remoting/client/plugin/pepper_input_handler.h"
 #include "remoting/client/plugin/pepper_port_allocator.h"
 #include "remoting/client/plugin/pepper_view.h"
 #include "remoting/client/plugin/pepper_xmpp_proxy.h"
 #include "remoting/client/rectangle_update_decoder.h"
 #include "remoting/protocol/connection_to_host.h"
 #include "remoting/protocol/host_stub.h"
-#include "remoting/protocol/input_event_tracker.h"
 #include "remoting/protocol/libjingle_transport_factory.h"
-#include "remoting/protocol/mouse_input_filter.h"
 
 // Windows defines 'PostMessage', so we have to undef it.
 #if defined(PostMessage)
 #undef PostMessage
 #endif
 
 namespace remoting {
 
 namespace {
 
@@ skipping 93 matching lines @@
 
   return true;
 }
 
 ChromotingInstance::ChromotingInstance(PP_Instance pp_instance)
     : pp::Instance(pp_instance),
       initialized_(false),
       plugin_task_runner_(
           new PluginThreadTaskRunner(&plugin_thread_delegate_)),
       context_(plugin_task_runner_),
+      input_tracker_(&mouse_input_filter_),
+#if defined(OS_MACOSX)
+      // On Mac we need an extra filter to inject missing keyup events.
+      // See remoting/client/plugin/mac_key_event_processor.h for more details.
+      mac_key_event_processor_(&input_tracker_),
+      key_mapper_(&mac_key_event_processor_),
+#else
+      key_mapper_(&input_tracker_),
+#endif
+      input_handler_(&key_mapper_),
       weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
   RequestInputEvents(PP_INPUTEVENT_CLASS_MOUSE | PP_INPUTEVENT_CLASS_WHEEL);
   RequestFilteringInputEvents(PP_INPUTEVENT_CLASS_KEYBOARD);
 
   // Resister this instance to handle debug log messsages.
   RegisterLoggingInstance();
 
   // Send hello message.
   scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   data->SetInteger("apiVersion", kApiVersion);
@@ skipping 171 matching lines @@
     }
     PauseVideo(pause);
   }
 }
 
 void ChromotingInstance::DidChangeView(const pp::View& view) {
   DCHECK(plugin_task_runner_->BelongsToCurrentThread());
 
   view_->SetView(view);
 
-  if (mouse_input_filter_.get()) {
-    mouse_input_filter_->set_input_size(view_->get_view_size_dips());
-  }
+  mouse_input_filter_.set_input_size(view_->get_view_size_dips());
 }
 
 bool ChromotingInstance::HandleInputEvent(const pp::InputEvent& event) {
   DCHECK(plugin_task_runner_->BelongsToCurrentThread());
 
   if (!IsConnected())
     return false;
 
   // TODO(wez): When we have a good hook into Host dimensions changes, move
   // this there.
-  // If |input_handler_| is valid, then |mouse_input_filter_| must also be
-  // since they are constructed together as part of the input pipeline
-  mouse_input_filter_->set_output_size(view_->get_screen_size());
+  mouse_input_filter_.set_output_size(view_->get_screen_size());
 
-  return input_handler_->HandleInputEvent(event);
+  return input_handler_.HandleInputEvent(event);
 }
 
 void ChromotingInstance::SetDesktopSize(const SkISize& size,
                                         const SkIPoint& dpi) {
   scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   data->SetInteger("width", size.width());
   data->SetInteger("height", size.height());
   if (dpi.x())
     data->SetInteger("x_dpi", dpi.x());
   if (dpi.y())
@@ skipping 92 matching lines @@
 
   jingle_glue::JingleThreadWrapper::EnsureForCurrentThread();
 
   host_connection_.reset(new protocol::ConnectionToHost(true));
   scoped_ptr<AudioPlayer> audio_player(new PepperAudioPlayer(this));
   client_.reset(new ChromotingClient(config, &context_,
                                      host_connection_.get(), this,
                                      rectangle_decoder_.get(),
                                      audio_player.Pass()));
 
-  // Construct the input pipeline
-  mouse_input_filter_.reset(
-      new protocol::MouseInputFilter(host_connection_->input_stub()));
-  mouse_input_filter_->set_input_size(view_->get_view_size_dips());
-  input_tracker_.reset(
-      new protocol::InputEventTracker(mouse_input_filter_.get()));
-
-#if defined(OS_MACOSX)
-  // On Mac we need an extra filter to inject missing keyup events.
-  // See remoting/client/plugin/mac_key_event_processor.h for more details.
-  mac_key_event_processor_.reset(
-      new MacKeyEventProcessor(input_tracker_.get()));
-  key_mapper_.set_input_stub(mac_key_event_processor_.get());
-#else
-  key_mapper_.set_input_stub(input_tracker_.get());
-#endif
-  input_handler_.reset(
-      new PepperInputHandler(&key_mapper_));
+  // Connect the input pipeline to the protocol stub & initialize components.
+  mouse_input_filter_.set_input_stub(host_connection_->input_stub());
+  mouse_input_filter_.set_input_size(view_->get_view_size_dips());
 
   LOG(INFO) << "Connecting to " << config.host_jid
             << ". Local jid: " << config.local_jid << ".";
 
   // Setup the XMPP Proxy.
   xmpp_proxy_ = new PepperXmppProxy(
       base::Bind(&ChromotingInstance::SendOutgoingIq, AsWeakPtr()),
       plugin_task_runner_, context_.main_task_runner());
 
   scoped_ptr<cricket::HttpPortAllocatorBase> port_allocator(
@@ skipping 19 matching lines @@
   LOG(INFO) << "Disconnecting from host.";
   if (client_.get()) {
     // TODO(sergeyu): Should we disconnect asynchronously?
     base::WaitableEvent done_event(true, false);
     client_->Stop(base::Bind(&base::WaitableEvent::Signal,
                              base::Unretained(&done_event)));
     done_event.Wait();
     client_.reset();
   }
 
-  input_handler_.reset();
-  input_tracker_.reset();
-  mouse_input_filter_.reset();
+  // Disconnect the input pipeline and teardown the connection.
+  mouse_input_filter_.set_input_stub(NULL);
   host_connection_.reset();
 }
 
 void ChromotingInstance::OnIncomingIq(const std::string& iq) {
   xmpp_proxy_->OnIq(iq);
 }
 
 void ChromotingInstance::ReleaseAllKeys() {
   if (IsConnected())
-    input_tracker_->ReleaseAll();
+    input_tracker_.ReleaseAll();
 }
 
 void ChromotingInstance::InjectKeyEvent(const protocol::KeyEvent& event) {
   // Inject after the KeyEventMapper, so the event won't get mapped or trapped.
   if (IsConnected())
-    input_tracker_->InjectKeyEvent(event);
+    input_tracker_.InjectKeyEvent(event);
 }
 
 void ChromotingInstance::RemapKey(uint32 in_usb_keycode,
                                   uint32 out_usb_keycode) {
   key_mapper_.RemapKey(in_usb_keycode, out_usb_keycode);
 }
 
 void ChromotingInstance::TrapKey(uint32 usb_keycode, bool trap) {
   key_mapper_.TrapKey(usb_keycode, trap);
 }
@@ skipping 181 matching lines @@
   PostChromotingMessage("logDebugMessage", data.Pass());
   g_logging_to_plugin = false;
 }
 
 bool ChromotingInstance::IsConnected() {
   return host_connection_.get() &&
     (host_connection_->state() == protocol::ConnectionToHost::CONNECTED);
 }
 
 }  // namespace remoting