Remove authenticated_ fields from stubs.

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/stl_util-inl.h"
 #include "base/task.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/capturer.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/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 141 matching lines @@
 }
 
 // This method is called when a client connects.
 void ChromotingHost::OnClientConnected(ConnectionToClient* connection) {
   DCHECK_EQ(context_->main_message_loop(), MessageLoop::current());
 }
 
 void ChromotingHost::OnClientDisconnected(ConnectionToClient* connection) {
   DCHECK_EQ(context_->main_message_loop(), MessageLoop::current());
 
+  // Find the client session corresponding to the given connection.
+  std::vector<scoped_refptr<ClientSession> >::iterator client;
+  for (client = clients_.begin(); client != clients_.end(); ++client) {
+    if (client->get()->connection() == connection)
+      break;
+  }
+  if (client == clients_.end())
+    return;
+
   // Remove the connection from the session manager and stop the session.
   // TODO(hclam): Stop only if the last connection disconnected.
   if (recorder_.get()) {
     recorder_->RemoveConnection(connection);
     // The recorder only exists to serve the unique authenticated client.
     // If that client has disconnected, then we can kill the recorder.
-    if (connection->client_authenticated()) {
+    if (client->get()->authenticated()) {
       recorder_->Stop(NULL);
       recorder_ = NULL;
     }
   }
 
   // Close the connection to connection just to be safe.
   connection->Disconnect();
 
   // Also remove reference to ConnectionToClient from this object.
-  std::vector<scoped_refptr<ClientSession> >::iterator it;
-  for (it = clients_.begin(); it != clients_.end(); ++it) {
-    if (it->get()->connection() == connection) {
-      clients_.erase(it);
-      break;
-    }
-  }
+  clients_.erase(client);
+
   if (!HasAuthenticatedClients())
     EnableCurtainMode(false);
 }
 
 ////////////////////////////////////////////////////////////////////////////
 // protocol::ConnectionToClient::EventHandler implementations
 void ChromotingHost::OnConnectionOpened(ConnectionToClient* connection) {
   DCHECK_EQ(context_->network_message_loop(), MessageLoop::current());
 
   // Completes the connection to the client.
@@ skipping 98 matching lines @@
   session->set_config(config);
   session->set_receiver_token(
       GenerateHostAuthToken(session->initiator_token()));
 
   *response = protocol::SessionManager::ACCEPT;
 
   VLOG(1) << "Client connected: " << session->jid();
 
   // We accept the connection, so create a connection object.
   ConnectionToClient* connection = new ConnectionToClient(
-      context_->network_message_loop(),
-      this,
-      desktop_environment_->input_stub());
+      context_->network_message_loop(), this);
 
   // Create a client object.
-  ClientSession* client = new ClientSession(this, connection);
+  ClientSession* client = new ClientSession(
+      this,
+      base::Bind(UserAuthenticator::Create),
+      connection,
+      desktop_environment_->input_stub());
   connection->set_host_stub(client);
+  connection->set_input_stub(client);
 
   connection->Init(session);
 
   clients_.push_back(client);
 }
 
 void ChromotingHost::set_protocol_config(
     protocol::CandidateSessionConfig* config) {
   DCHECK(config_.get());
   DCHECK_EQ(state_, kInitial);
@@ skipping 29 matching lines @@
 
 std::string ChromotingHost::GenerateHostAuthToken(
     const std::string& encoded_client_token) {
   // TODO(ajwong): Return the signature of this instead.
   return encoded_client_token;
 }
 
 bool ChromotingHost::HasAuthenticatedClients() const {
   std::vector<scoped_refptr<ClientSession> >::const_iterator it;
   for (it = clients_.begin(); it != clients_.end(); ++it) {
-    if (it->get()->connection()->client_authenticated())
+    if (it->get()->authenticated())
       return true;
   }
   return false;
 }
 
 void ChromotingHost::EnableCurtainMode(bool enable) {
   // TODO(jamiewalch): This will need to be more sophisticated when we think
   // about proper crash recovery and daemon mode.
   if (enable == is_curtained_)
     return;
@@ skipping 10 matching lines @@
                           &ChromotingHost::LocalLoginSucceeded,
                           connection));
     return;
   }
 
   protocol::LocalLoginStatus* status = new protocol::LocalLoginStatus();
   status->set_success(true);
   connection->client_stub()->BeginSessionResponse(
       status, new DeleteTask<protocol::LocalLoginStatus>(status));
 
-  connection->OnClientAuthenticated();
-
   // Disconnect all other clients.
   // Iterate over a copy of the list of clients, to avoid mutating the list
   // while iterating over it.
   std::vector<scoped_refptr<ClientSession> > clients_copy(clients_);
   std::vector<scoped_refptr<ClientSession> >::const_iterator client;
   for (client = clients_copy.begin(); client != clients_copy.end(); client++) {
     ConnectionToClient* connection_other = client->get()->connection();
     if (connection_other != connection) {
       OnClientDisconnected(connection_other);
     }
@@ skipping 29 matching lines @@
     return;
   }
 
   protocol::LocalLoginStatus* status = new protocol::LocalLoginStatus();
   status->set_success(false);
   connection->client_stub()->BeginSessionResponse(
       status, new DeleteTask<protocol::LocalLoginStatus>(status));
 }
 
 }  // namespace remoting