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 142 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 == "getTokenFromAuthCode") {

[Lambros, 2015/04/22 18:28:52]

Please update me2me_native_messaging_host_unittest.cc for this new request type.
You can simply validate that this new request triggers a correctly-formatted
response, similar to what we do for the other request types.

[John Williams, 2015/04/22 20:11:25]

It looks like to do this, I will have to make remoting::OAuthClient abstract and
write a mock class.  Is that what I should do?  And if so, does this breakdown
of files/classes work for you?

  OAuthClient(abstract)   oauth_client.{cc,h}
  GaiaOAuthClient         oauth_client.{cc,h}
  MockOAuthClient         mock_oauth_client.{cc,h}

[Lambros, 2015/04/22 21:22:59]

OK, I thought it would be a simple addition to the existing unittests. But it
seems we've only mocked the DaemonController but not yet the OAuthClient. Your
suggestion looks good - we definitely want to have this, but I think it's fine
to do it as a separate CL.

+    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 274 matching lines @@
 
 bool Me2MeNativeMessagingHost::DelegateToElevatedHost(
     scoped_ptr<base::DictionaryValue> message) {
   NOTREACHED();
   return false;
 }
 
 #endif  // !defined(OS_WIN)
 
 }  // namespace remoting