Remove video_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/message_loop.h"
 #include "remoting/base/constants.h"
@@ skipping 20 matching lines @@
     talk_base::PacketSocketFactory* socket_factory,
     HostResolverFactory* host_resolver_factory,
     PortAllocatorSessionFactory* session_factory,
     bool allow_nat_traversal)
     : message_loop_(message_loop),
       network_manager_(network_manager),
       socket_factory_(socket_factory),
       host_resolver_factory_(host_resolver_factory),
       port_allocator_session_factory_(session_factory),
       allow_nat_traversal_(allow_nat_traversal),
+      event_callback_(NULL),
+      client_stub_(NULL),
+      video_stub_(NULL),
       state_(STATE_EMPTY),
-      event_callback_(NULL),
-      dispatcher_(new ClientMessageDispatcher()),
-      client_stub_(NULL),
-      video_stub_(NULL) {
+      control_connected_(false),
+      input_connected_(false),
+      video_connected_(false) {
 }
 
 ConnectionToHost::~ConnectionToHost() {
 }
 
 InputStub* ConnectionToHost::input_stub() {
   return input_sender_.get();
 }
 
 HostStub* ConnectionToHost::host_stub() {
@@ skipping 113 matching lines @@
 }
 
 void ConnectionToHost::OnSessionStateChange(
     Session::State state) {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   DCHECK(event_callback_);
 
   switch (state) {
     case Session::FAILED:
       state_ = STATE_FAILED;
-      CloseChannels();
-      event_callback_->OnConnectionFailed(this);
+      CloseOnError();
       break;
 
     case Session::CLOSED:
       state_ = STATE_CLOSED;
       CloseChannels();
       event_callback_->OnConnectionClosed(this);
       break;
 
     case Session::CONNECTED:
-      state_ = STATE_CONNECTED;
       // Initialize reader and writer.
       video_reader_.reset(VideoReader::Create(session_->config()));
-      video_reader_->Init(session_.get(), video_stub_);
+      video_reader_->Init(
+          session_.get(), video_stub_,
+          base::Bind(&ConnectionToHost::OnVideoChannelInitialized,
+                     base::Unretained(this)));
+      break;
+
+    case Session::CONNECTED_CHANNELS:
+      state_ = STATE_CONNECTED;
       host_control_sender_.reset(
           new HostControlSender(session_->control_channel()));
+      dispatcher_.reset(new ClientMessageDispatcher());
       dispatcher_->Initialize(session_.get(), client_stub_);
-      event_callback_->OnConnectionOpened(this);
+
+      control_connected_ = true;
+      input_connected_ = true;
+      NotifyIfChannelsReady();
       break;
 
     default:
       // Ignore the other states by default.
       break;
   }
 }
 
+void ConnectionToHost::OnVideoChannelInitialized(bool successful) {
+  if (!successful) {
+    LOG(ERROR) << "Failed to connect video channel";
+    CloseOnError();
+    return;
+  }
+
+  video_connected_ = true;
+  NotifyIfChannelsReady();
+}
+
+void ConnectionToHost::NotifyIfChannelsReady() {
+  if (control_connected_ && input_connected_ && video_connected_)
+    event_callback_->OnConnectionOpened(this);
+}
+
+void ConnectionToHost::CloseOnError() {
+  state_ = STATE_FAILED;
+  CloseChannels();
+  event_callback_->OnConnectionFailed(this);
+}
+
 void ConnectionToHost::CloseChannels() {
   if (input_sender_.get())
     input_sender_->Close();
 
   if (host_control_sender_.get())
     host_control_sender_->Close();
+
+  video_reader_.reset();
 }
 
 void ConnectionToHost::OnClientAuthenticated() {
   // TODO(hclam): Don't send anything except authentication request if it is
   // not authenticated.
   state_ = STATE_AUTHENTICATED;
 
   // Create and enable the input stub now that we're authenticated.
   input_sender_.reset(new InputSender(session_->event_channel()));
 }
 
 ConnectionToHost::State ConnectionToHost::state() const {
   return state_;
 }
 
 }  // namespace protocol
 }  // namespace remoting