Move ClientSession's input logic into separate components.

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 20 matching lines @@
 #include "remoting/client/chromoting_client.h"
 #include "remoting/client/frame_consumer_proxy.h"
 #include "remoting/client/mouse_input_filter.h"
 #include "remoting/client/plugin/chromoting_scriptable_object.h"
 #include "remoting/client/plugin/pepper_input_handler.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/key_event_tracker.h"
+#include "remoting/protocol/input_event_tracker.h"
 
 // Windows defines 'PostMessage', so we have to undef it.
 #if defined(PostMessage)
 #undef PostMessage
 #endif
 
 namespace remoting {
 
 namespace {
 
@@ skipping 304 matching lines @@
   host_connection_.reset(new protocol::ConnectionToHost(
       context_.network_message_loop(), this, true));
   client_.reset(new ChromotingClient(config, &context_, host_connection_.get(),
                                      view_.get(), rectangle_decoder_.get(),
                                      base::Closure()));
 
   // Construct the input pipeline
   mouse_input_filter_.reset(
       new MouseInputFilter(host_connection_->input_stub()));
   mouse_input_filter_->set_input_size(view_->get_view_size());
-  key_event_tracker_.reset(
-      new protocol::KeyEventTracker(mouse_input_filter_.get()));
+  input_tracker_.reset(
+      new protocol::InputEventTracker(mouse_input_filter_.get()));
   input_handler_.reset(
-      new PepperInputHandler(key_event_tracker_.get()));
+      new PepperInputHandler(input_tracker_.get()));
 
   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_message_loop_,
       context_.network_message_loop());
 
@@ skipping 16 matching lines @@
   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();
-  key_event_tracker_.reset();
+  input_tracker_.reset();
   mouse_input_filter_.reset();
   host_connection_.reset();
 
   SetConnectionState(STATE_CLOSED, ERROR_NONE);
 }
 
 void ChromotingInstance::OnIncomingIq(const std::string& iq) {
   xmpp_proxy_->OnIq(iq);
 }
 
 void ChromotingInstance::ReleaseAllKeys() {
-  if (key_event_tracker_.get())
-    key_event_tracker_->ReleaseAllKeys();
+  if (input_tracker_.get())
+    input_tracker_->ReleaseAll();
 }
 
 void ChromotingInstance::InjectKeyEvent(const protocol::KeyEvent& event) {
-  if (key_event_tracker_.get())
-    key_event_tracker_->InjectKeyEvent(event);
+  if (input_tracker_.get())
+    input_tracker_->InjectKeyEvent(event);
 }
 
 void ChromotingInstance::SendClipboardItem(const std::string& mime_type,
                                            const std::string& item) {
   // TODO(simonmorris): Plumb this in to a ClipboardStub.
 }
 
 ChromotingStats* ChromotingInstance::GetStats() {
   if (!client_.get())
     return NULL;
@@ skipping 135 matching lines @@
     scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
     data->SetString("message", message);
     PostChromotingMessage("logDebugMessage", data.Pass());
 
     scriptable_object->LogDebugInfo(message);
   }
   g_logging_to_plugin = false;
 }
 
 }  // namespace remoting