Use Authenticator interface in Session and SessionManager

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"
 #include "remoting/base/constants.h"
 #include "remoting/jingle_glue/javascript_signal_strategy.h"
 #include "remoting/jingle_glue/xmpp_signal_strategy.h"
 #include "remoting/protocol/auth_util.h"
 #include "remoting/protocol/client_control_dispatcher.h"
 #include "remoting/protocol/client_event_dispatcher.h"
 #include "remoting/protocol/client_stub.h"
 #include "remoting/protocol/jingle_session_manager.h"
 #include "remoting/protocol/pepper_session_manager.h"
+#include "remoting/protocol/v1_authenticator.h"
 #include "remoting/protocol/video_reader.h"
 #include "remoting/protocol/video_stub.h"
 #include "remoting/protocol/util.h"
 
 namespace remoting {
 namespace protocol {
 
 ConnectionToHost::ConnectionToHost(
     base::MessageLoopProxy* message_loop,
     pp::Instance* pp_instance,
@@ skipping 63 matching lines @@
     signal_strategy_.reset();
 
   shutdown_task.Run();
 }
 
 void ConnectionToHost::InitSession() {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   session_manager_.reset(new PepperSessionManager(pp_instance_));
   session_manager_->Init(
-      local_jid_, signal_strategy_.get(), this, NULL, "", allow_nat_traversal_);
+      local_jid_, signal_strategy_.get(), this, allow_nat_traversal_);
 }
 
 const SessionConfig& ConnectionToHost::config() {
   return session_->config();
 }
 
 void ConnectionToHost::OnStateChange(
     SignalStrategy::StatusObserver::State state) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK(event_callback_);
@@ skipping 11 matching lines @@
   DCHECK(message_loop_->BelongsToCurrentThread());
   local_jid_ = full_jid;
 }
 
 void ConnectionToHost::OnSessionManagerInitialized() {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   // After SessionManager is initialized we can try to connect to the host.
   CandidateSessionConfig* candidate_config =
       CandidateSessionConfig::CreateDefault();
-  std::string client_token =
-      protocol::GenerateSupportAuthToken(local_jid_, access_code_);
+  V1ClientAuthenticator* authenticator =
+      new V1ClientAuthenticator(local_jid_, access_code_);
   session_.reset(session_manager_->Connect(
-      host_jid_, host_public_key_, client_token, candidate_config,
+      host_jid_, authenticator, candidate_config,
       base::Bind(&ConnectionToHost::OnSessionStateChange,
                  base::Unretained(this))));
-
-  // Set the shared-secret for securing SSL channels.
-  session_->set_shared_secret(access_code_);
 }
 
 void ConnectionToHost::OnIncomingSession(
     Session* session,
     SessionManager::IncomingSessionResponse* response) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   // Client always rejects incoming sessions.
   *response = SessionManager::DECLINE;
 }
 
@@ skipping 93 matching lines @@
 
   if (state != state_) {
     state_ = state;
     error_ = error;
     event_callback_->OnConnectionState(state_, error_);
   }
 }
 
 }  // namespace protocol
 }  // namespace remoting