Added method to host daemon to exchange an auth code for just an OAuth

remoting/host/setup/me2me_native_messaging_host.cc

 // Copyright 2013 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/setup/me2me_native_messaging_host.h"
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 31 matching lines @@
 const int kElevatedHostTimeoutSeconds = 300;
 #endif  // defined(OS_WIN)
 
 // redirect_uri to use when authenticating service accounts (service account
 // codes are obtained "out-of-band", i.e., not through an OAuth redirect).
 const char* kServiceAccountRedirectUri = "oob";
 
 // Features supported in addition to the base protocol.
 const char* kSupportedFeatures[] = {
   "pairingRegistry",
-  "oauthClient"
+  "oauthClient",
+  "getRefreshTokenFromAuthCode",
 };
 
 // Helper to extract the "config" part of a message as a DictionaryValue.
 // Returns nullptr on failure, and logs an error message.
 scoped_ptr<base::DictionaryValue> ConfigDictionaryFromMessage(
     scoped_ptr<base::DictionaryValue> message) {
   scoped_ptr<base::DictionaryValue> result;
   const base::DictionaryValue* config_dict;
   if (message->GetDictionary("config", &config_dict)) {
     result.reset(config_dict->DeepCopy());
@@ skipping 90 matching lines @@
     ProcessGetUsageStatsConsent(message_dict.Pass(), response.Pass());
   } else if (type == "startDaemon") {
     ProcessStartDaemon(message_dict.Pass(), response.Pass());
   } else if (type == "stopDaemon") {
     ProcessStopDaemon(message_dict.Pass(), response.Pass());
   } else if (type == "getDaemonState") {
     ProcessGetDaemonState(message_dict.Pass(), response.Pass());
   } else if (type == "getHostClientId") {
     ProcessGetHostClientId(message_dict.Pass(), response.Pass());
   } else if (type == "getCredentialsFromAuthCode") {
-    ProcessGetCredentialsFromAuthCode(message_dict.Pass(), response.Pass());
+    ProcessGetCredentialsFromAuthCode(
+        message_dict.Pass(), response.Pass(), true);
+  } else if (type == "getRefreshTokenFromAuthCode") {
+    ProcessGetCredentialsFromAuthCode(
+        message_dict.Pass(), response.Pass(), false);
   } else {
     LOG(ERROR) << "Unsupported request type: " << type;
     OnError();
   }
 }
 
 void Me2MeNativeMessagingHost::OnDisconnect() {
   if (!quit_closure_.is_null())
     base::ResetAndReturn(&quit_closure_).Run();
 }
@@ skipping 241 matching lines @@
     scoped_ptr<base::DictionaryValue> response) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   response->SetString("clientId", google_apis::GetOAuth2ClientID(
       google_apis::CLIENT_REMOTING_HOST));
   channel_->SendMessage(response.Pass());
 }
 
 void Me2MeNativeMessagingHost::ProcessGetCredentialsFromAuthCode(
     scoped_ptr<base::DictionaryValue> message,
-    scoped_ptr<base::DictionaryValue> response) {
+    scoped_ptr<base::DictionaryValue> response,
+    bool need_user_email) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   std::string auth_code;
   if (!message->GetString("authorizationCode", &auth_code)) {
     LOG(ERROR) << "'authorizationCode' string not found.";
     OnError();
     return;
   }
 
   gaia::OAuthClientInfo oauth_client_info = {
     google_apis::GetOAuth2ClientID(google_apis::CLIENT_REMOTING_HOST),
     google_apis::GetOAuth2ClientSecret(google_apis::CLIENT_REMOTING_HOST),
     kServiceAccountRedirectUri
   };
 
   oauth_client_->GetCredentialsFromAuthCode(
-      oauth_client_info, auth_code, base::Bind(
+      oauth_client_info, auth_code, need_user_email, base::Bind(
           &Me2MeNativeMessagingHost::SendCredentialsResponse, weak_ptr_,
           base::Passed(&response)));
 }
 
 void Me2MeNativeMessagingHost::SendConfigResponse(
     scoped_ptr<base::DictionaryValue> response,
     scoped_ptr<base::DictionaryValue> config) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (config) {
@@ skipping 53 matching lines @@
   response->SetBoolean("result", result);
   channel_->SendMessage(response.Pass());
 }
 
 void Me2MeNativeMessagingHost::SendCredentialsResponse(
     scoped_ptr<base::DictionaryValue> response,
     const std::string& user_email,
     const std::string& refresh_token) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  response->SetString("userEmail", user_email);
+  if (!user_email.empty()) {
+    response->SetString("userEmail", user_email);
+  }
   response->SetString("refreshToken", refresh_token);
   channel_->SendMessage(response.Pass());
 }
 
 void Me2MeNativeMessagingHost::OnError() {
   // Trigger a host shutdown by sending a nullptr message.
   channel_->SendMessage(nullptr);
 }
 
 void Me2MeNativeMessagingHost::Stop() {
@@ skipping 200 matching lines @@
 
 bool Me2MeNativeMessagingHost::DelegateToElevatedHost(
     scoped_ptr<base::DictionaryValue> message) {
   NOTREACHED();
   return false;
 }
 
 #endif  // !defined(OS_WIN)
 
 }  // namespace remoting