Add AUTHENTICATED session state.

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 141 matching lines @@
 ConnectionToHost::State ConnectionToHost::state() const {
   return state_;
 }
 
 void ConnectionToHost::OnSessionStateChange(
     Session::State state) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK(event_callback_);
 
   switch (state) {
+    case Session::INITIALIZING:
+    case Session::CONNECTING:
+    case Session::CONNECTED:
+      // Don't care about these events.
+      break;
+
+    case Session::AUTHENTICATED:
+      video_reader_.reset(VideoReader::Create(
+          message_loop_, session_->config()));
+      video_reader_->Init(session_.get(), video_stub_, base::Bind(
+          &ConnectionToHost::OnChannelInitialized, base::Unretained(this)));
+
+      control_dispatcher_.reset(new ClientControlDispatcher());
+      control_dispatcher_->Init(session_.get(), base::Bind(
+          &ConnectionToHost::OnChannelInitialized, base::Unretained(this)));
+      control_dispatcher_->set_client_stub(client_stub_);
+
+      event_dispatcher_.reset(new ClientEventDispatcher());
+      event_dispatcher_->Init(session_.get(), base::Bind(
+          &ConnectionToHost::OnChannelInitialized, base::Unretained(this)));
+      break;
+
+    case Session::CLOSED:
+      CloseChannels();
+      SetState(CLOSED, OK);
+      break;
+
     case Session::FAILED:
       switch (session_->error()) {
         case Session::PEER_IS_OFFLINE:
           CloseOnError(HOST_IS_OFFLINE);
           break;
         case Session::SESSION_REJECTED:
         case Session::AUTHENTICATION_FAILED:
           CloseOnError(SESSION_REJECTED);
           break;
         case Session::INCOMPATIBLE_PROTOCOL:
           CloseOnError(INCOMPATIBLE_PROTOCOL);
           break;
         case Session::CHANNEL_CONNECTION_ERROR:
           CloseOnError(NETWORK_FAILURE);
           break;
         case Session::OK:
           DLOG(FATAL) << "Error code isn't set";
           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::OnChannelInitialized, base::Unretained(this)));
-
-      control_dispatcher_.reset(new ClientControlDispatcher());
-      control_dispatcher_->Init(session_.get(), base::Bind(
-          &ConnectionToHost::OnChannelInitialized, base::Unretained(this)));
-      control_dispatcher_->set_client_stub(client_stub_);
-
-      event_dispatcher_.reset(new ClientEventDispatcher());
-      event_dispatcher_->Init(session_.get(), base::Bind(
-          &ConnectionToHost::OnChannelInitialized, base::Unretained(this)));
-      break;
-
-    default:
-      // Ignore the other states by default.
-      break;
   }
 }
 
 void ConnectionToHost::OnChannelInitialized(bool successful) {
   if (!successful) {
     LOG(ERROR) << "Failed to connect video channel";
     CloseOnError(NETWORK_FAILURE);
     return;
   }
 
   NotifyIfChannelsReady();
 }
 
 void ConnectionToHost::NotifyIfChannelsReady() {
   if (control_dispatcher_.get() && control_dispatcher_->is_connected() &&
       event_dispatcher_.get() && event_dispatcher_->is_connected() &&
       video_reader_.get() && video_reader_->is_connected() &&
       state_ == CONNECTING) {
     SetState(CONNECTED, OK);
-    SetState(AUTHENTICATED, OK);
   }
 }
 
 void ConnectionToHost::CloseOnError(Error error) {
   CloseChannels();
   SetState(FAILED, error);
 }
 
 void ConnectionToHost::CloseChannels() {
   control_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