Remove old Authentication code that we don't use or need.

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 137 matching lines @@
 }
 
 void ConnectionToHost::OnIncomingSession(
     Session* session,
     SessionManager::IncomingSessionResponse* response) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   // Client always rejects incoming sessions.
   *response = SessionManager::DECLINE;
 }
 
-void ConnectionToHost::OnClientAuthenticated() {
-  // TODO(hclam): Don't send anything except authentication request if it is
-  // not authenticated.
-  SetState(AUTHENTICATED, OK);
-
-  // Create and enable the input stub now that we're authenticated.
-  input_sender_.reset(
-      new InputSender(message_loop_, session_->event_channel()));
-}
-
 ConnectionToHost::State ConnectionToHost::state() const {
   return state_;
 }
 
 void ConnectionToHost::OnSessionStateChange(
     Session::State state) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK(event_callback_);
 
   switch (state) {
@@ skipping 27 matching lines @@
           VideoReader::Create(message_loop_, session_->config()));
       video_reader_->Init(
           session_.get(), video_stub_,
           base::Bind(&ConnectionToHost::OnVideoChannelInitialized,
                      base::Unretained(this)));
       break;
 
     case Session::CONNECTED_CHANNELS:
       host_control_sender_.reset(
           new HostControlSender(message_loop_, session_->control_channel()));
+      input_sender_.reset(
+          new InputSender(message_loop_, session_->event_channel()));
       dispatcher_.reset(new ClientMessageDispatcher());
       dispatcher_->Initialize(session_.get(), client_stub_);
 
       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(NETWORK_FAILURE);
     return;
   }
 
   video_connected_ = true;
   NotifyIfChannelsReady();
 }
 
 void ConnectionToHost::NotifyIfChannelsReady() {
   if (control_connected_ && input_connected_ && video_connected_ &&
       state_ == CONNECTING) {
     SetState(CONNECTED, OK);
+    SetState(AUTHENTICATED, OK);
   }
 }
 
 void ConnectionToHost::CloseOnError(Error error) {
   CloseChannels();
   SetState(FAILED, error);
 }
 
 void ConnectionToHost::CloseChannels() {
   if (input_sender_.get())
@@ skipping 12 matching lines @@
 
   if (state != state_) {
     state_ = state;
     error_ = error;
     event_callback_->OnConnectionState(state_, error_);
   }
 }
 
 }  // namespace protocol
 }  // namespace remoting