Remoting daemon process to support unofficial client ID

remoting/host/remoting_me2me_host.cc

 // Copyright (c) 2012 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.
 //
 // This file implements a standalone host process for Me2Me.
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 
@@ skipping 49 matching lines @@
 const char kHostConfigSwitchName[] = "host-config";
 
 const FilePath::CharType kDefaultAuthConfigFile[] =
     FILE_PATH_LITERAL("auth.json");
 const FilePath::CharType kDefaultHostConfigFile[] =
     FILE_PATH_LITERAL("host.json");
 
 const int kMinPortNumber = 12400;
 const int kMaxPortNumber = 12409;
 
+const remoting::OAuthClientInfo kUnofficialOAuth2ClientInfo = {
+  "440925447803-2pi3v45bff6tp1rde2f7q6lgbor3o5uj.apps.googleusercontent.com",
+  "W2ieEsG-R1gIA4MMurGrgMc_"
+};
+
+const remoting::OAuthClientInfo kOfficialOAuth2ClientInfo = {
+  "440925447803-avn2sj1kc099s0r7v62je5s339mu0am1.apps.googleusercontent.com",
+  "Bgur6DFiOMM1h8x-AQpuTQlK"
+};
+
 }  // namespace
 
 namespace remoting {
 
 class HostProcess
     : public HeartbeatSender::Listener {
  public:
   HostProcess()
       : message_loop_(MessageLoop::TYPE_UI),
+#ifdef OFFICIAL_BUILD
+        oauth_use_official_client_id_(true),
+#else
+        oauth_use_official_client_id_(false),
+#endif
         allow_nat_traversal_(true),
         restarting_(false),
         exit_code_(kSuccessExitCode) {
     context_.reset(
         new ChromotingHostContext(message_loop_.message_loop_proxy()));
     context_->Start();
     network_change_notifier_.reset(net::NetworkChangeNotifier::Create());
     config_updated_timer_.reset(new base::DelayTimer<HostProcess>(
         FROM_HERE, base::TimeDelta::FromSeconds(2), this,
         &HostProcess::ConfigUpdated));
@@ skipping 144 matching lines @@
 
     // Use an XMPP connection to the Talk network for session signalling.
     if (!auth_config.GetString(kXmppLoginConfigPath, &xmpp_login_) ||
         !(auth_config.GetString(kXmppAuthTokenConfigPath, &xmpp_auth_token_) ||
           auth_config.GetString(kOAuthRefreshTokenConfigPath,
                                 &oauth_refresh_token_))) {
       LOG(ERROR) << "XMPP credentials are not defined in the config.";
       return false;
     }
 
+    // It is okay to not have this value and we will use the default value
+    // depending on whether this is an official build or not.

[Wez, 2012/04/20 22:29:46]

nit: Suggest "If the client-Id type to use is not specified we default based on
the build type"

+    auth_config.GetBoolean(kOAuthUseOfficialClientIdConfigPath,
+                           &oauth_use_official_client_id_);
+
     if (!oauth_refresh_token_.empty()) {
       xmpp_auth_token_ = "";  // This will be set to the access token later.
       xmpp_auth_service_ = "oauth2";
     } else if (!auth_config.GetString(kXmppAuthServiceConfigPath,
                                       &xmpp_auth_service_)) {
       // For the me2me host, we default to ClientLogin token for chromiumsync
       // because earlier versions of the host had no HTTP stack with which to
       // request an OAuth2 access token.
       xmpp_auth_service_ = kChromotingTokenDefaultServiceName;
     }
@@ skipping 28 matching lines @@
 
     if (!signal_strategy_.get()) {
       signal_strategy_.reset(
           new XmppSignalStrategy(context_->jingle_thread(), xmpp_login_,
                                  xmpp_auth_token_, xmpp_auth_service_));
 
       signaling_connector_.reset(
           new SignalingConnector(signal_strategy_.get()));
 
       if (!oauth_refresh_token_.empty()) {
+        OAuthClientInfo client_info = kUnofficialOAuth2ClientInfo;
+
+#ifdef OFFICIAL_BUILD
+        if (oauth_use_official_client_id_) {
+          client_info = kOfficialOAuth2ClientInfo;
+        }
+#endif  // OFFICIAL_BUILD
+
         scoped_ptr<SignalingConnector::OAuthCredentials> oauth_credentials(
             new SignalingConnector::OAuthCredentials(
-                xmpp_login_, oauth_refresh_token_));
+                xmpp_login_, oauth_refresh_token_, client_info));
         signaling_connector_->EnableOAuth(
             oauth_credentials.Pass(),
             base::Bind(&HostProcess::OnOAuthFailed, base::Unretained(this)),
             context_->url_request_context_getter());
       }
     }
 
     if (!desktop_environment_.get()) {
       desktop_environment_ =
           DesktopEnvironment::CreateForService(context_.get());
@@ skipping 62 matching lines @@
   FilePath host_config_path_;
 
   std::string host_id_;
   HostKeyPair key_pair_;
   protocol::SharedSecretHash host_secret_hash_;
   std::string xmpp_login_;
   std::string xmpp_auth_token_;
   std::string xmpp_auth_service_;
 
   std::string oauth_refresh_token_;
+  bool oauth_use_official_client_id_;
 
   scoped_ptr<policy_hack::NatPolicy> nat_policy_;
   bool allow_nat_traversal_;
   scoped_ptr<base::files::FilePathWatcher> config_watcher_;
   scoped_ptr<base::DelayTimer<HostProcess> > config_updated_timer_;
 
   bool restarting_;
 
   scoped_ptr<XmppSignalStrategy> signal_strategy_;
   scoped_ptr<SignalingConnector> signaling_connector_;
@@ skipping 49 matching lines @@
 int CALLBACK WinMain(HINSTANCE instance,
                      HINSTANCE previous_instance,
                      LPSTR command_line,
                      int show_command) {
   // CommandLine::Init() ignores the passed |argc| and |argv| on Windows getting
   // the command line from GetCommandLineW(), so we can safely pass NULL here.
   return main(0, NULL);
 }
 
 #endif