Wire in OAuth2 support into non-sandboxed connections in libjingle.

remoting/protocol/protocol_test_client.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 "build/build_config.h"
 
 #if !defined(OS_WIN)
 extern "C" {
 #include <unistd.h>
 }
 #endif  // !defined(OS_WIN)
 
 #include <iostream>
 #include <list>
 
 #include "base/at_exit.h"
 #include "base/command_line.h"
 #include "base/test/mock_chrome_application_mac.h"
 #include "base/time.h"
 #include "crypto/nss_util.h"
 #include "net/base/completion_callback.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/socket/socket.h"
 #include "remoting/base/constants.h"
 #include "remoting/jingle_glue/jingle_client.h"
 #include "remoting/jingle_glue/jingle_thread.h"
 #include "remoting/protocol/jingle_session_manager.h"
 
-using remoting::kChromotingTokenServiceName;
-
 namespace remoting {
 namespace protocol {
 
 namespace {
 const int kBufferSize = 4096;
 const char kDummyAuthToken[] = "";
 }  // namespace
 
 class ProtocolTestClient;
 
@@ skipping 174 matching lines @@
     std::string str(reinterpret_cast<const char*>(read_buffer_->data()),
                     result);
     std::cout << "(" << session_->jid() << "): " << str << std::endl;
   } else {
     LOG(ERROR) << "Read() returned error " << result;
   }
 }
 
 void ProtocolTestClient::Run(const std::string& username,
                              const std::string& auth_token,
+                             const std::string& auth_service,
                              const std::string& host_jid) {
   remoting::JingleThread jingle_thread;
   jingle_thread.Start();
   signal_strategy_.reset(
       new XmppSignalStrategy(&jingle_thread, username, auth_token,
-                             kChromotingTokenServiceName));
+                             auth_service));
   client_ = new JingleClient(&jingle_thread, signal_strategy_.get(),
                              NULL, NULL, NULL, this);
   client_->Init();
 
   session_manager_ = new JingleSessionManager(&jingle_thread);
 
   host_jid_ = host_jid;
 
   while (true) {
     std::string line;
@@ skipping 125 matching lines @@
   std::string host_jid(cmd_line->GetSwitchValueASCII("host_jid"));
 
   if (!cmd_line->HasSwitch("username"))
     usage(argv[0]);
   std::string username(cmd_line->GetSwitchValueASCII("username"));
 
   if (!cmd_line->HasSwitch("auth_token"))
     usage(argv[0]);
   std::string auth_token(cmd_line->GetSwitchValueASCII("auth_token"));
 
+  // Default to OAuth2 for the auth token.
+  std::string auth_service("oauth2");
+  if (cmd_line->HasSwitch("auth_service"))
+    auth_service = cmd_line->GetSwitchValueASCII("auth_service");
+
   scoped_refptr<ProtocolTestClient> client(new ProtocolTestClient());
 
-  client->Run(username, auth_token, host_jid);
+  client->Run(username, auth_token, host_jid, auth_service);
 
   return 0;
 }