Remove event_channel() and control_channel() from Session interface.

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/host_control_dispatcher.h"
 #include "remoting/protocol/host_event_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),
       session_(session),
-      control_connected_(false),
-      input_connected_(false),
-      video_connected_(false) {
+      control_channel_connected_(false),
+      event_channel_connected_(false),
+      video_channel_connected_(false) {
   session_->SetStateChangeCallback(
       base::Bind(&ConnectionToClient::OnSessionStateChange,
                  base::Unretained(this)));
 }
 
 ConnectionToClient::~ConnectionToClient() {
   if (session_.get()) {
     base::MessageLoopProxy::current()->DeleteSoon(
         FROM_HERE, session_.release());
   }
@@ skipping 56 matching lines @@
 void ConnectionToClient::OnSessionStateChange(protocol::Session::State state) {
   DCHECK(CalledOnValidThread());
 
   DCHECK(handler_);
   switch(state) {
     case protocol::Session::CONNECTING:
       // Don't care about this message.
       break;
 
     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;
+      // Initialize channels.
+      control_dispatcher_.reset(new HostControlDispatcher());
+      control_dispatcher_->Init(session_.get(), base::Bind(
+          &ConnectionToClient::OnControlChannelInitialized,
+          base::Unretained(this)));
+      control_dispatcher_->set_host_stub(host_stub_);
 
-    case protocol::Session::CONNECTED_CHANNELS:
-      control_dispatcher_.reset(new HostControlDispatcher());
-      control_dispatcher_->Init(session_.get());
-      control_dispatcher_->set_host_stub(host_stub_);
-      input_dispatcher_.reset(new HostEventDispatcher());
-      input_dispatcher_->Init(session_.get());
-      input_dispatcher_->set_input_stub(input_stub_);
-      input_dispatcher_->set_sequence_number_callback(base::Bind(
+      event_dispatcher_.reset(new HostEventDispatcher());
+      event_dispatcher_->Init(session_.get(), base::Bind(
+          &ConnectionToClient::OnEventChannelInitialized,
+          base::Unretained(this)));
+      event_dispatcher_->set_input_stub(input_stub_);
+      event_dispatcher_->set_sequence_number_callback(base::Bind(
           &ConnectionToClient::UpdateSequenceNumber, base::Unretained(this)));
 
-      control_connected_ = true;
-      input_connected_ = true;
-      NotifyIfChannelsReady();
+      video_writer_.reset(VideoWriter::Create(
+          base::MessageLoopProxy::current(), session_->config()));
+      video_writer_->Init(session_.get(), base::Bind(
+          &ConnectionToClient::OnVideoChannelInitialized,
+          base::Unretained(this)));
+
       break;
 
     case protocol::Session::CLOSED:
       CloseChannels();
       handler_->OnConnectionClosed(this);
       break;
 
     case protocol::Session::FAILED:
       CloseOnError();
       break;
 
     default:
       // We shouldn't receive other states.
       NOTREACHED();
   }
 }
 
-void ConnectionToClient::OnVideoInitialized(bool successful) {
+void ConnectionToClient::OnControlChannelInitialized(bool successful) {
   DCHECK(CalledOnValidThread());
 
   if (!successful) {
+    LOG(ERROR) << "Failed to connect control channel";
+    CloseOnError();
+    return;
+  }
+
+  control_channel_connected_ = true;
+  NotifyIfChannelsReady();
+}
+
+void ConnectionToClient::OnEventChannelInitialized(bool successful) {
+  DCHECK(CalledOnValidThread());
+
+  if (!successful) {
+    LOG(ERROR) << "Failed to connect event channel";
+    CloseOnError();
+    return;
+  }
+
+  event_channel_connected_ = true;
+  NotifyIfChannelsReady();
+}
+
+void ConnectionToClient::OnVideoChannelInitialized(bool successful) {
+  DCHECK(CalledOnValidThread());
+
+  if (!successful) {
     LOG(ERROR) << "Failed to connect video channel";
     CloseOnError();
     return;
   }
 
-  video_connected_ = true;
+  video_channel_connected_ = true;
   NotifyIfChannelsReady();
 }
 
 void ConnectionToClient::NotifyIfChannelsReady() {
   DCHECK(CalledOnValidThread());
 
-  if (control_connected_ && input_connected_ && video_connected_)
+  if (control_channel_connected_ && event_channel_connected_ &&
+      video_channel_connected_) {
     handler_->OnConnectionOpened(this);
+  }
 }
 
 void ConnectionToClient::CloseOnError() {
   CloseChannels();
   handler_->OnConnectionFailed(this);
 }
 
 void ConnectionToClient::CloseChannels() {
   control_dispatcher_.reset();
-  input_dispatcher_.reset();
+  event_dispatcher_.reset();
   video_writer_.reset();
 }
 
 }  // namespace protocol
 }  // namespace remoting