Refactor client channel dispatchers.

remoting/protocol/connection_to_host.cc

 // 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.
 
 #include "remoting/protocol/connection_to_host.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/message_loop_proxy.h"
 #include "remoting/base/constants.h"
 #include "remoting/jingle_glue/javascript_signal_strategy.h"
 #include "remoting/jingle_glue/xmpp_signal_strategy.h"
 #include "remoting/protocol/auth_token_utils.h"
-#include "remoting/protocol/client_message_dispatcher.h"
+#include "remoting/protocol/client_control_dispatcher.h"
+#include "remoting/protocol/client_input_dispatcher.h"
 #include "remoting/protocol/client_stub.h"
-#include "remoting/protocol/host_control_sender.h"
-#include "remoting/protocol/input_sender.h"
 #include "remoting/protocol/jingle_session_manager.h"
 #include "remoting/protocol/pepper_session_manager.h"
 #include "remoting/protocol/video_reader.h"
 #include "remoting/protocol/video_stub.h"
 #include "remoting/protocol/util.h"
 
 namespace remoting {
 namespace protocol {
 
 ConnectionToHost::ConnectionToHost(
@@ skipping 10 matching lines @@
       error_(OK),
       control_connected_(false),
       input_connected_(false),
       video_connected_(false) {
 }
 
 ConnectionToHost::~ConnectionToHost() {
 }
 
 InputStub* ConnectionToHost::input_stub() {
-  return input_sender_.get();
+  return input_dispatcher_.get();
 }
 
 HostStub* ConnectionToHost::host_stub() {
-  return host_control_sender_.get();
+  return control_dispatcher_.get();
 }
 
 void ConnectionToHost::Connect(scoped_refptr<XmppProxy> xmpp_proxy,
                                const std::string& your_jid,
                                const std::string& host_jid,
                                const std::string& host_public_key,
                                const std::string& access_code,
                                HostEventCallback* event_callback,
                                ClientStub* client_stub,
                                VideoStub* video_stub) {
@@ skipping 129 matching lines @@
     case Session::CONNECTED:
       video_reader_.reset(
           VideoReader::Create(message_loop_, session_->config()));
       video_reader_->Init(
           session_.get(), video_stub_,
           base::Bind(&ConnectionToHost::OnVideoChannelInitialized,
                      base::Unretained(this)));
       break;
 
     case Session::CONNECTED_CHANNELS:
-      host_control_sender_.reset(
-          new HostControlSender(message_loop_, session_->control_channel()));
-      input_sender_.reset(
-          new InputSender(message_loop_, session_->event_channel()));
-      dispatcher_.reset(new ClientMessageDispatcher());
-      dispatcher_->Initialize(session_.get(), client_stub_);
+      control_dispatcher_.reset(
+          new ClientControlDispatcher(message_loop_));
+      control_dispatcher_->Init(session_.get(), client_stub_);
+      input_dispatcher_.reset(
+          new ClientInputDispatcher(message_loop_));
+      input_dispatcher_->Init(session_.get());
 
       control_connected_ = true;
       input_connected_ = true;
       NotifyIfChannelsReady();
       break;
 
     default:
       // Ignore the other states by default.
       break;
   }
@@ skipping 17 matching lines @@
     SetState(AUTHENTICATED, OK);
   }
 }
 
 void ConnectionToHost::CloseOnError(Error error) {
   CloseChannels();
   SetState(FAILED, error);
 }
 
 void ConnectionToHost::CloseChannels() {
-  if (input_sender_.get())
-    input_sender_->Close();
-
-  if (host_control_sender_.get())
-    host_control_sender_->Close();
-
+  control_dispatcher_.reset();
+  input_dispatcher_.reset();
   video_reader_.reset();
 }
 
 void ConnectionToHost::SetState(State state, Error error) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   // |error| should be specified only when |state| is set to FAILED.
   DCHECK(state == FAILED || error == OK);
 
   if (state != state_) {
     state_ = state;
     error_ = error;
     event_callback_->OnConnectionState(state_, error_);
   }
 }
 
 }  // namespace protocol
 }  // namespace remoting