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

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"
@@ skipping 18 matching lines @@
     pp::Instance* pp_instance,
     bool allow_nat_traversal)
     : message_loop_(message_loop),
       pp_instance_(pp_instance),
       allow_nat_traversal_(allow_nat_traversal),
       event_callback_(NULL),
       client_stub_(NULL),
       video_stub_(NULL),
       state_(CONNECTING),
       error_(OK),
-      control_connected_(false),
-      input_connected_(false),
-      video_connected_(false) {
+      control_channel_connected_(false),
+      event_channel_connected_(false),
+      video_channel_connected_(false) {
 }
 
 ConnectionToHost::~ConnectionToHost() {
 }
 
 InputStub* ConnectionToHost::input_stub() {
-  return input_dispatcher_.get();
+  return event_dispatcher_.get();
 }
 
 HostStub* ConnectionToHost::host_stub() {
   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,
@@ skipping 124 matching lines @@
           CloseOnError(NETWORK_FAILURE);
       }
       break;
 
     case Session::CLOSED:
       CloseChannels();
       SetState(CLOSED, OK);
       break;
 
     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;
+      video_reader_.reset(VideoReader::Create(
+          message_loop_, session_->config()));
+      video_reader_->Init(session_.get(), video_stub_, base::Bind(
+          &ConnectionToHost::OnVideoChannelInitialized,
+          base::Unretained(this)));
 
-    case Session::CONNECTED_CHANNELS:
       control_dispatcher_.reset(new ClientControlDispatcher());
-      control_dispatcher_->Init(session_.get());
+      control_dispatcher_->Init(session_.get(), base::Bind(
+          &ConnectionToHost::OnControlChannelInitialized,
+          base::Unretained(this)));
       control_dispatcher_->set_client_stub(client_stub_);
-      input_dispatcher_.reset(new ClientEventDispatcher());
-      input_dispatcher_->Init(session_.get());
 
-      control_connected_ = true;
-      input_connected_ = true;
-      NotifyIfChannelsReady();
+      event_dispatcher_.reset(new ClientEventDispatcher());
+      event_dispatcher_->Init(session_.get(), base::Bind(
+          &ConnectionToHost::OnEventChannelInitialized,
+          base::Unretained(this)));
       break;
 
     default:
       // Ignore the other states by default.
       break;
   }
 }
 
+void ConnectionToHost::OnControlChannelInitialized(bool successful) {
+  if (!successful) {
+    LOG(ERROR) << "Failed to connect video channel";
+    CloseOnError(NETWORK_FAILURE);
+    return;
+  }
+
+  control_channel_connected_ = true;
+  NotifyIfChannelsReady();
+}
+
+
+void ConnectionToHost::OnEventChannelInitialized(bool successful) {
+  if (!successful) {
+    LOG(ERROR) << "Failed to connect video channel";
+    CloseOnError(NETWORK_FAILURE);
+    return;
+  }
+
+  event_channel_connected_ = true;
+  NotifyIfChannelsReady();
+}
+
+
 void ConnectionToHost::OnVideoChannelInitialized(bool successful) {
   if (!successful) {
     LOG(ERROR) << "Failed to connect video channel";
     CloseOnError(NETWORK_FAILURE);
     return;
   }
 
-  video_connected_ = true;
+  video_channel_connected_ = true;
   NotifyIfChannelsReady();
 }
 
 void ConnectionToHost::NotifyIfChannelsReady() {
-  if (control_connected_ && input_connected_ && video_connected_ &&
-      state_ == CONNECTING) {
+  if (control_channel_connected_ && event_channel_connected_ &&
+      video_channel_connected_ && state_ == CONNECTING) {
     SetState(CONNECTED, OK);
     SetState(AUTHENTICATED, OK);
   }
 }
 
 void ConnectionToHost::CloseOnError(Error error) {
   CloseChannels();
   SetState(FAILED, error);
 }
 
 void ConnectionToHost::CloseChannels() {
   control_dispatcher_.reset();
-  input_dispatcher_.reset();
+  event_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