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

remoting/host/chromoting_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/host/chromoting_host.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/message_loop_proxy.h"
 #include "build/build_config.h"
 #include "remoting/base/constants.h"
 #include "remoting/base/encoder.h"
 #include "remoting/base/encoder_row_based.h"
 #include "remoting/base/encoder_vp8.h"
 #include "remoting/host/chromoting_host_context.h"
 #include "remoting/host/curtain.h"
 #include "remoting/host/desktop_environment.h"
 #include "remoting/host/event_executor.h"
 #include "remoting/host/host_config.h"
 #include "remoting/host/host_key_pair.h"
 #include "remoting/host/screen_recorder.h"
 #include "remoting/host/user_authenticator.h"
 #include "remoting/jingle_glue/xmpp_signal_strategy.h"
-#include "remoting/proto/auth.pb.h"
 #include "remoting/protocol/connection_to_client.h"
 #include "remoting/protocol/client_stub.h"
 #include "remoting/protocol/host_stub.h"
 #include "remoting/protocol/input_stub.h"
 #include "remoting/protocol/jingle_session_manager.h"
 #include "remoting/protocol/session_config.h"
 
 using remoting::protocol::ConnectionToClient;
 using remoting::protocol::InputStub;
 
@@ skipping 104 matching lines @@
 void ChromotingHost::AddStatusObserver(HostStatusObserver* observer) {
   DCHECK_EQ(state_, kInitial);
   status_observers_.push_back(observer);
 }
 
 ////////////////////////////////////////////////////////////////////////////
 // protocol::ConnectionToClient::EventHandler implementations
 void ChromotingHost::OnConnectionOpened(ConnectionToClient* connection) {
   DCHECK(context_->network_message_loop()->BelongsToCurrentThread());
   VLOG(1) << "Connection to client established.";
-  // TODO(wez): ChromotingHost shouldn't need to know about Me2Mom.
-  if (is_it2me_) {
-    context_->main_message_loop()->PostTask(
-        FROM_HERE, base::Bind(&ChromotingHost::ProcessPreAuthentication, this,
+  context_->main_message_loop()->PostTask(
+      FROM_HERE, base::Bind(&ChromotingHost::ProcessPreAuthentication, this,
                               make_scoped_refptr(connection)));
-  }
 }
 
 void ChromotingHost::OnConnectionClosed(ConnectionToClient* connection) {
   DCHECK(context_->network_message_loop()->BelongsToCurrentThread());
 
   VLOG(1) << "Connection to client closed.";
   context_->main_message_loop()->PostTask(
       FROM_HERE, base::Bind(&ChromotingHost::OnClientDisconnected, this,
                             make_scoped_refptr(connection)));
 }
@@ skipping 131 matching lines @@
   LOG(INFO) << "Client connected: " << session->jid();
 
   // We accept the connection, so create a connection object.
   ConnectionToClient* connection = new ConnectionToClient(
       context_->network_message_loop(), this);
   connection->Init(session);
 
   // Create a client object.
   ClientSession* client = new ClientSession(
       this,
-      UserAuthenticator::Create(),
       connection,
       desktop_environment_->event_executor(),
       desktop_environment_->capturer());
   connection->set_host_stub(client);
   connection->set_input_stub(client);
 
   clients_.push_back(client);
 }
 
 void ChromotingHost::set_protocol_config(
@@ skipping 57 matching lines @@
   if (recorder_.get()) {
     recorder_->RemoveConnection(connection);
   }
 
   // Close the connection to client just to be safe.
   // TODO(garykac): This should be removed when we revisit our shutdown and
   // disconnect code. This should only need to be done in
   // ClientSession::Disconnect().
   connection->Disconnect();
 
-  if (client->authenticated()) {
-    for (StatusObserverList::iterator it = status_observers_.begin();
-         it != status_observers_.end(); ++it) {
-      (*it)->OnClientDisconnected(client->client_jid());
-    }
+  for (StatusObserverList::iterator it = status_observers_.begin();
+       it != status_observers_.end(); ++it) {
+    (*it)->OnClientDisconnected(client->client_jid());
   }
 
   if (AuthenticatedClientsCount() == 0) {
     if (recorder_.get()) {
       // Stop the recorder if there are no more clients.
       StopScreenRecorder();
     }
 
     // Disable the "curtain" if there are no more active clients.
     EnableCurtainMode(false);
@@ skipping 39 matching lines @@
 void ChromotingHost::EnableCurtainMode(bool enable) {
   // TODO(jamiewalch): This will need to be more sophisticated when we think
   // about proper crash recovery and daemon mode.
   // TODO(wez): CurtainMode shouldn't be driven directly by ChromotingHost.
   if (is_it2me_ || enable == is_curtained_)
     return;
   desktop_environment_->curtain()->EnableCurtainMode(enable);
   is_curtained_ = enable;
 }
 
-void ChromotingHost::LocalLoginSucceeded(
+void ChromotingHost::OnAuthenticationComplete(
     scoped_refptr<ConnectionToClient> connection) {
   DCHECK(context_->network_message_loop()->BelongsToCurrentThread());
 
   context_->main_message_loop()->PostTask(
       FROM_HERE, base::Bind(&ChromotingHost::AddAuthenticatedClient,
                             this, connection, connection->session()->config(),
                             connection->session()->jid()));
 }
 
 void ChromotingHost::AddAuthenticatedClient(
     scoped_refptr<ConnectionToClient> connection,
     const protocol::SessionConfig& config,
     const std::string& jid) {
   DCHECK_EQ(context_->main_message_loop(), MessageLoop::current());
 
-  protocol::LocalLoginStatus* status = new protocol::LocalLoginStatus();
-  status->set_success(true);
-  connection->client_stub()->BeginSessionResponse(
-      status, base::Bind(&DeletePointer<protocol::LocalLoginStatus>, status));
-
   // Disconnect all other clients.
   // Iterate over a copy of the list of clients, to avoid mutating the list
   // while iterating over it.
   ClientList clients_copy(clients_);
   for (ClientList::const_iterator client = clients_copy.begin();
        client != clients_copy.end(); client++) {
     ConnectionToClient* connection_other = client->get()->connection();
     if (connection_other != connection) {
       OnClientDisconnected(connection_other);
     }
@@ skipping 27 matching lines @@
   EnableCurtainMode(true);
   if (is_it2me_) {
     std::string username = jid;
     size_t pos = username.find('/');
     if (pos != std::string::npos)
       username.replace(pos, std::string::npos, "");
     desktop_environment_->OnConnect(username);
   }
 }
 
-void ChromotingHost::LocalLoginFailed(
-    scoped_refptr<ConnectionToClient> connection) {
-  if (MessageLoop::current() != context_->main_message_loop()) {
-    context_->main_message_loop()->PostTask(
-        FROM_HERE, base::Bind(&ChromotingHost::LocalLoginFailed, this,
-                              connection));
-    return;
-  }
-
-  protocol::LocalLoginStatus* status = new protocol::LocalLoginStatus();
-  status->set_success(false);
-  connection->client_stub()->BeginSessionResponse(
-      status, base::Bind(&DeletePointer<protocol::LocalLoginStatus>, status));
-}
-
 void ChromotingHost::ProcessPreAuthentication(
     const scoped_refptr<ConnectionToClient>& connection) {
   DCHECK_EQ(context_->main_message_loop(), MessageLoop::current());
   // Find the client session corresponding to the given connection.
   ClientList::iterator client;
   for (client = clients_.begin(); client != clients_.end(); ++client) {
     if (client->get()->connection() == connection)
       break;
   }
   CHECK(client != clients_.end());
 
   context_->network_message_loop()->PostTask(
-      FROM_HERE, base::Bind(&ClientSession::OnAuthorizationComplete,
-                            client->get(), true));
+      FROM_HERE, base::Bind(&ClientSession::OnAuthenticationComplete,
+                            client->get()));
 }
 
 void ChromotingHost::StopScreenRecorder() {
   DCHECK(MessageLoop::current() == context_->main_message_loop());
   DCHECK(recorder_.get());
 
   ++stopping_recorders_;
   recorder_->Stop(base::Bind(&ChromotingHost::OnScreenRecorderStopped, this));
   recorder_ = NULL;
 }
@@ skipping 83 matching lines @@
 
   for (std::vector<Task*>::iterator it = shutdown_tasks_.begin();
        it != shutdown_tasks_.end(); ++it) {
     (*it)->Run();
     delete *it;
   }
   shutdown_tasks_.clear();
 }
 
 }  // namespace remoting