Merge 176800

google_apis/gaia/gaia_auth_fetcher.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.
 
 #include "google_apis/gaia/gaia_auth_fetcher.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/values.h"
 #include "google_apis/gaia/gaia_auth_consumer.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "google_apis/gaia/gaia_urls.h"
 #include "google_apis/gaia/google_service_auth_error.h"
 #include "net/base/escape.h"
 #include "net/base/load_flags.h"
+#include "net/http/http_response_headers.h"
 #include "net/http/http_status_code.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_status.h"
 
 namespace {
 const int kLoadFlagsIgnoreCookies = net::LOAD_DO_NOT_SEND_COOKIES |
                                     net::LOAD_DO_NOT_SAVE_COOKIES;
 
 static bool CookiePartsContains(const std::vector<std::string>& parts,
@@ skipping 115 matching lines @@
 
 // static
 const char GaiaAuthFetcher::kSecondFactor[] = "Info=InvalidSecondFactor";
 
 // static
 const char GaiaAuthFetcher::kAuthHeaderFormat[] =
     "Authorization: GoogleLogin auth=%s";
 // static
 const char GaiaAuthFetcher::kOAuthHeaderFormat[] = "Authorization: OAuth %s";
 // static
+const char GaiaAuthFetcher::kOAuth2BearerHeaderFormat[] =
+    "Authorization: Bearer %s";
+// static
 const char GaiaAuthFetcher::kClientLoginToOAuth2CookiePartSecure[] = "Secure";
 // static
 const char GaiaAuthFetcher::kClientLoginToOAuth2CookiePartHttpOnly[] =
     "HttpOnly";
 // static
 const char GaiaAuthFetcher::kClientLoginToOAuth2CookiePartCodePrefix[] =
     "oauth_code=";
 // static
 const int GaiaAuthFetcher::kClientLoginToOAuth2CookiePartCodePrefixLength =
     arraysize(GaiaAuthFetcher::kClientLoginToOAuth2CookiePartCodePrefix) - 1;
@@ skipping 178 matching lines @@
 
 // Helper method that extracts tokens from a successful reply.
 // static
 void GaiaAuthFetcher::ParseClientLoginResponse(const std::string& data,
                                                std::string* sid,
                                                std::string* lsid,
                                                std::string* token) {
   using std::vector;
   using std::pair;
   using std::string;
-
+  sid->clear();
+  lsid->clear();
+  token->clear();
   vector<pair<string, string> > tokens;
   base::SplitStringIntoKeyValuePairs(data, '=', '\n', &tokens);
   for (vector<pair<string, string> >::iterator i = tokens.begin();
       i != tokens.end(); ++i) {
     if (i->first == "SID") {
       sid->assign(i->second);
     } else if (i->first == "LSID") {
       lsid->assign(i->second);
     } else if (i->first == "Auth") {
       token->assign(i->second);
     }
   }
+  // If this was a request for uberauth token, then that's all we've got in
+  // data.
+  if (sid->empty() && lsid->empty() && token->empty())
+    token->assign(data);
 }
 
 // static
 std::string GaiaAuthFetcher::MakeClientOAuthBody(
     const std::string& username,
     const std::string& password,
     const std::vector<std::string>& scopes,
     const std::string& persistent_id,
     const std::string& friendly_name,
     const std::string& locale) {
@@ skipping 47 matching lines @@
   std::string json_string;
   base::JSONWriter::Write(dict.get(), &json_string);
   return json_string;
 }
 
 // static
 std::string GaiaAuthFetcher::MakeOAuthLoginBody(const std::string& service,
                                                 const std::string& source) {
   std::string encoded_service = net::EscapeUrlEncodedData(service, true);
   std::string encoded_source = net::EscapeUrlEncodedData(source, true);
-  return StringPrintf(kOAuthLoginFormat, encoded_service.c_str(),
+  return StringPrintf(kOAuthLoginFormat,
+                      encoded_service.c_str(),
                       encoded_source.c_str());
 }
 
 // static
 void GaiaAuthFetcher::ParseClientLoginFailure(const std::string& data,
                                               std::string* error,
                                               std::string* error_url,
                                               std::string* captcha_url,
                                               std::string* captcha_token) {
   using std::vector;
@@ skipping 315 matching lines @@
   fetch_pending_ = true;
   fetcher_->Start();
 }
 
 void GaiaAuthFetcher::StartOAuthLogin(const std::string& access_token,
                                       const std::string& service) {
   DCHECK(!fetch_pending_) << "Tried to fetch two things at once!";
 
   request_body_ = MakeOAuthLoginBody(service, source_);
   std::string authentication_header =
-      base::StringPrintf("Authorization: Bearer %s", access_token.c_str());
+      base::StringPrintf(kOAuth2BearerHeaderFormat, access_token.c_str());
   fetcher_.reset(CreateGaiaFetcher(getter_,
                                    request_body_,
                                    authentication_header,
                                    oauth_login_gurl_,
                                    kLoadFlagsIgnoreCookies,
                                    this));
   fetch_pending_ = true;
   fetcher_->Start();
 }
 
@@ skipping 281 matching lines @@
 void GaiaAuthFetcher::OnURLFetchComplete(const net::URLFetcher* source) {
   fetch_pending_ = false;
   // Some of the GAIA requests perform redirects, which results in the final
   // URL of the fetcher not being the original URL requested.  Therefore use
   // the original URL when determining which OnXXX function to call.
   const GURL& url = source->GetOriginalURL();
   const net::URLRequestStatus& status = source->GetStatus();
   int response_code = source->GetResponseCode();
   std::string data;
   source->GetResponseAsString(&data);
-  DVLOG(2) << "Gaia fetcher response code: " << response_code;
-  DVLOG(2) << "Gaia fetcher response data: " << data;
+#ifndef NDEBUG
+  std::string headers;
+  if (source->GetResponseHeaders())
+    source->GetResponseHeaders()->GetNormalizedHeaders(&headers);
+  DVLOG(2) << "Response " << url.spec() << ", code = " << response_code << "\n"
+           << headers << "\n";
+  DVLOG(2) << "data: " << data << "\n";
+#endif
+  // Retrieve the response headers from the request.  Must only be called after
+  // the OnURLFetchComplete callback has run.
   if (url == client_login_gurl_) {
     OnClientLoginFetched(data, status, response_code);
   } else if (url == issue_auth_token_gurl_) {
     OnIssueAuthTokenFetched(data, status, response_code);
   } else if (url == client_login_to_oauth2_gurl_) {
     OnClientLoginToOAuth2Fetched(
         data, source->GetCookies(), status, response_code);
   } else if (url == oauth2_token_gurl_) {
     OnOAuth2TokenPairFetched(data, status, response_code);
   } else if (url == get_user_info_gurl_) {
@@ skipping 10 matching lines @@
     NOTREACHED();
   }
 }
 
 // static
 bool GaiaAuthFetcher::IsSecondFactorSuccess(
     const std::string& alleged_error) {
   return alleged_error.find(kSecondFactor) !=
       std::string::npos;
 }