Token-based authentication for chromoting.

remoting/host/simple_host.cc

 // Copyright (c) 2010 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/simple_host.h"
 
 #include "base/stl_util-inl.h"
 #include "build/build_config.h"
+#include "remoting/base/constants.h"
 #include "remoting/base/protocol_decoder.h"
 #include "remoting/host/session_manager.h"
 #include "remoting/jingle_glue/jingle_channel.h"
 
 namespace remoting {
 
 SimpleHost::SimpleHost(const std::string& username,
-                       const std::string& password,
+                       const std::string& auth_token,
                        Capturer* capturer,
                        Encoder* encoder,
                        EventExecutor* executor)
       : capture_thread_("CaptureThread"),
         encode_thread_("EncodeThread"),
         username_(username),
-        password_(password),
+        auth_token_(auth_token),
         capturer_(capturer),
         encoder_(encoder),
         executor_(executor) {
 }
 
 void SimpleHost::Run() {
   DCHECK_EQ(&main_loop_, MessageLoop::current());
 
   // Submit a task to perform host registration. We'll also start
   // listening to connection if registration is done.
@@ skipping 18 matching lines @@
 }
 
 // This method talks to the cloud to register the host process. If
 // successful we will start listening to network requests.
 void SimpleHost::RegisterHost() {
   DCHECK_EQ(&main_loop_, MessageLoop::current());
   DCHECK(!jingle_client_);
 
   // Connect to the talk network with a JingleClient.
   jingle_client_ = new JingleClient();
-  jingle_client_->Init(username_, password_, this);
+  jingle_client_->Init(username_, auth_token_,
+                       kChromotingTokenServiceName, this);
 }
 
 // This method is called if a client is connected to this object.
 void SimpleHost::OnClientConnected(ClientConnection* client) {
   DCHECK_EQ(&main_loop_, MessageLoop::current());
 
   // Create a new RecordSession if there was none.
   if (!session_) {
     // The first we need to make sure capture and encode thread are
     // running.
@@ skipping 119 matching lines @@
                                  scoped_refptr<JingleChannel> channel) {
   DCHECK_EQ(jingle_client_.get(), jingle_client);
 
   // Since the session manager has not started, it is still safe to access
   // the client directly. Note that we give the ownership of the channel
   // to the client.
   client_->set_jingle_channel(channel);
 }
 
 }  // namespace remoting