Refactor channel dispatchers on the host side.

remoting/protocol/connection_to_client.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_client.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/message_loop_proxy.h"
 #include "google/protobuf/message.h"
 #include "net/base/io_buffer.h"
-#include "remoting/protocol/client_control_sender.h"
-#include "remoting/protocol/host_message_dispatcher.h"
+#include "remoting/protocol/host_control_dispatcher.h"
+#include "remoting/protocol/host_input_dispatcher.h"
 #include "remoting/protocol/host_stub.h"
 #include "remoting/protocol/input_stub.h"
 
 namespace remoting {
 namespace protocol {
 
 ConnectionToClient::ConnectionToClient(protocol::Session* session)
     : handler_(NULL),
       host_stub_(NULL),
       input_stub_(NULL),
@@ skipping 47 matching lines @@
 }
 
 VideoStub* ConnectionToClient::video_stub() {
   DCHECK(CalledOnValidThread());
   return video_writer_.get();
 }
 
 // Return pointer to ClientStub.
 ClientStub* ConnectionToClient::client_stub() {
   DCHECK(CalledOnValidThread());
-  return client_control_sender_.get();
+  return control_dispatcher_.get();
 }
 
 void ConnectionToClient::set_host_stub(protocol::HostStub* host_stub) {
   DCHECK(CalledOnValidThread());
   host_stub_ = host_stub;
 }
 
 void ConnectionToClient::set_input_stub(protocol::InputStub* input_stub) {
   DCHECK(CalledOnValidThread());
   input_stub_ = input_stub;
@@ skipping 11 matching lines @@
     case protocol::Session::CONNECTED:
       video_writer_.reset(
           VideoWriter::Create(base::MessageLoopProxy::current(),
                               session_->config()));
       video_writer_->Init(
           session_.get(), base::Bind(&ConnectionToClient::OnVideoInitialized,
                                      base::Unretained(this)));
       break;
 
     case protocol::Session::CONNECTED_CHANNELS:
-      client_control_sender_.reset(
-          new ClientControlSender(base::MessageLoopProxy::current(),
-                                  session_->control_channel()));
-      dispatcher_.reset(new HostMessageDispatcher());
-      dispatcher_->Initialize(this, host_stub_, input_stub_);
+      control_dispatcher_.reset(
+          new HostControlDispatcher(base::MessageLoopProxy::current()));
+      control_dispatcher_->Init(session_.get(), host_stub_);
+      input_dispatcher_.reset(new HostInputDispatcher());
+      input_dispatcher_->Init(session_.get(), input_stub_, base::Bind(
+          &ConnectionToClient::UpdateSequenceNumber, base::Unretained(this)));
 
       control_connected_ = true;
       input_connected_ = true;
       NotifyIfChannelsReady();
       break;
 
     case protocol::Session::CLOSED:
       CloseChannels();
       handler_->OnConnectionClosed(this);
       break;
@@ skipping 27 matching lines @@
   if (control_connected_ && input_connected_ && video_connected_)
     handler_->OnConnectionOpened(this);
 }
 
 void ConnectionToClient::CloseOnError() {
   CloseChannels();
   handler_->OnConnectionFailed(this);
 }
 
 void ConnectionToClient::CloseChannels() {
-  if (video_writer_.get())
-    video_writer_->Close();
-  if (client_control_sender_.get())
-    client_control_sender_->Close();
+  control_dispatcher_.reset();
+  input_dispatcher_.reset();
+  video_writer_.reset();
 }
 
 }  // namespace protocol
 }  // namespace remoting