Adding service_name to GaiaOAuthFetcher

chrome/browser/net/gaia/gaia_oauth_fetcher.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 "chrome/browser/net/gaia/gaia_oauth_fetcher.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 36 matching lines @@
     "https://www.google.com/accounts/OAuthLogin";
 
 static const char kUserInfoUrl[] =
     "https://www.googleapis.com/oauth2/v1/userinfo";
 
 static const char kOAuthTokenCookie[] = "oauth_token";
 
 GaiaOAuthFetcher::GaiaOAuthFetcher(GaiaOAuthConsumer* consumer,
                                    net::URLRequestContextGetter* getter,
                                    Profile* profile,
+                                   const std::string& service_name,
                                    const std::string& service_scope)
     : consumer_(consumer),
       getter_(getter),
       profile_(profile),
+      popup_(NULL),
+      service_name_(service_name),
       service_scope_(service_scope),
-      popup_(NULL),
       fetch_pending_(false),
       auto_fetch_limit_(ALL_OAUTH_STEPS) {}
 
 GaiaOAuthFetcher::~GaiaOAuthFetcher() {}
 
 bool GaiaOAuthFetcher::HasPendingFetch() {
   return fetch_pending_;
 }
 
 void GaiaOAuthFetcher::CancelRequest() {
@@ skipping 123 matching lines @@
   base::SplitStringIntoKeyValuePairs(data, '=', '&', &tokens);
   for (vector<pair<string, string> >::iterator i = tokens.begin();
        i != tokens.end(); ++i) {
     if (i->first == "oauth_token") {
       std::string decoded;
       if (OAuthRequestSigner::Decode(i->second, &decoded))
         token->assign(decoded);
     }
   }
 }
+
 // Helper method that extracts tokens from a successful reply.
 // static
 void GaiaOAuthFetcher::ParseOAuthLoginResponse(
     const std::string& data,
     std::string* sid,
     std::string* lsid,
     std::string* auth) {
   using std::vector;
   using std::pair;
   using std::string;
@@ skipping 182 matching lines @@
                                    false,
                                    this));
   fetch_pending_ = true;
   fetcher_->Start();
 }
 
 void GaiaOAuthFetcher::StartOAuthWrapBridge(
     const std::string& oauth1_access_token,
     const std::string& oauth1_access_token_secret,
     const std::string& wrap_token_duration,
-    const std::string& oauth2_scope) {
+    const std::string& service_name,
+    const std::string& service_scope) {
   DCHECK(!fetch_pending_) << "Tried to fetch two things at once!";
 
-  std::string combined_oauth2_scope = oauth2_scope + " " +
+  VLOG(1) << "Starting OAuthWrapBridge for: " << service_name;
+  std::string combined_scope = service_scope + " " +
       kOAuthWrapBridgeUserInfoScope;
+  service_name_ = service_name;
 
   // Must outlive fetcher_.
   request_body_ = MakeOAuthWrapBridgeBody(
       oauth1_access_token,
       oauth1_access_token_secret,
       wrap_token_duration,
-      combined_oauth2_scope);
+      combined_scope);
 
   request_headers_ = "";
   fetcher_.reset(CreateGaiaFetcher(getter_,
                                    GURL(kOAuthWrapBridgeUrl),
                                    request_body_,
                                    request_headers_,
                                    false,
                                    this));
   fetch_pending_ = true;
   fetcher_->Start();
@@ skipping 151 matching lines @@
     const std::string& data,
     const net::URLRequestStatus& status,
     int response_code) {
   if (status.is_success() && response_code == RC_REQUEST_OK) {
     VLOG(1) << "OAuth1 access token fetched.";
     std::string secret;
     std::string token;
     ParseOAuthGetAccessTokenResponse(data, &token, &secret);
     consumer_->OnOAuthGetAccessTokenSuccess(token, secret);
     if (ShouldAutoFetch(OAUTH2_SERVICE_ACCESS_TOKEN))
-      StartOAuthWrapBridge(token, secret, "3600", service_scope_);
+      StartOAuthWrapBridge(
+          token, secret, "3600", service_name_, service_scope_);
   } else {
     consumer_->OnOAuthGetAccessTokenFailure(GenerateAuthError(data, status));
   }
 }
 
 void GaiaOAuthFetcher::OnOAuthWrapBridgeFetched(
     const std::string& data,
     const net::URLRequestStatus& status,
     int response_code) {
   if (status.is_success() && response_code == RC_REQUEST_OK) {
     VLOG(1) << "OAuth2 access token fetched.";
     std::string token;
     std::string expires_in;
     ParseOAuthWrapBridgeResponse(data, &token, &expires_in);
-    consumer_->OnOAuthWrapBridgeSuccess(token, expires_in);
+    consumer_->OnOAuthWrapBridgeSuccess(service_name_, token, expires_in);
     if (ShouldAutoFetch(USER_INFO))
       StartUserInfo(token);
   } else {
     consumer_->OnOAuthWrapBridgeFailure(GenerateAuthError(data, status));
   }
 }
 
 void GaiaOAuthFetcher::OnUserInfoFetched(
     const std::string& data,
     const net::URLRequestStatus& status,
@@ skipping 28 matching lines @@
   } else if (url.spec() == kUserInfoUrl) {
     OnUserInfoFetched(data, status, response_code);
   } else {
     NOTREACHED();
   }
 }
 
 bool GaiaOAuthFetcher::ShouldAutoFetch(AutoFetchLimit fetch_step) {
   return fetch_step <= auto_fetch_limit_;
 }