Adjust URLFetcher::Create API so that object is returned as scoped_ptr.

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 <string>
 #include <utility>
 #include <vector>
 
@@ skipping 207 matching lines @@
 bool GaiaAuthFetcher::HasPendingFetch() {
   return fetch_pending_;
 }
 
 void GaiaAuthFetcher::CancelRequest() {
   fetcher_.reset();
   fetch_pending_ = false;
 }
 
 // static
-net::URLFetcher* GaiaAuthFetcher::CreateGaiaFetcher(
+scoped_ptr<net::URLFetcher> GaiaAuthFetcher::CreateGaiaFetcher(
     net::URLRequestContextGetter* getter,
     const std::string& body,
     const std::string& headers,
     const GURL& gaia_gurl,
     int load_flags,
     net::URLFetcherDelegate* delegate) {
-  net::URLFetcher* to_return = net::URLFetcher::Create(
-      0, gaia_gurl,
-      body.empty() ? net::URLFetcher::GET : net::URLFetcher::POST,
+  scoped_ptr<net::URLFetcher> to_return = net::URLFetcher::Create(
+      0, gaia_gurl, body.empty() ? net::URLFetcher::GET : net::URLFetcher::POST,
       delegate);
   to_return->SetRequestContext(getter);
   to_return->SetUploadData("application/x-www-form-urlencoded", body);
 
   DVLOG(2) << "Gaia fetcher URL: " << gaia_gurl.spec();
   DVLOG(2) << "Gaia fetcher headers: " << headers;
   DVLOG(2) << "Gaia fetcher body: " << body;
 
   // The Gaia token exchange requests do not require any cookie-based
   // identification as part of requests.  We suppress sending any cookies to
@@ skipping 338 matching lines @@
   DVLOG(1) << "Starting new ClientLogin fetch for:" << username;
 
   // Must outlive fetcher_.
   request_body_ = MakeClientLoginBody(username,
                                       password,
                                       source_,
                                       service,
                                       login_token,
                                       login_captcha,
                                       allow_hosted_accounts);
-  fetcher_.reset(CreateGaiaFetcher(getter_,
-                                   request_body_,
-                                   std::string(),
-                                   client_login_gurl_,
-                                   kLoadFlagsIgnoreCookies,
-                                   this));
+  fetcher_ =
+      CreateGaiaFetcher(getter_, request_body_, std::string(),
+                        client_login_gurl_, kLoadFlagsIgnoreCookies, this);
   fetch_pending_ = true;
   fetcher_->Start();
 }
 
 void GaiaAuthFetcher::StartIssueAuthToken(const std::string& sid,
                                           const std::string& lsid,
                                           const char* const service) {
   DCHECK(!fetch_pending_) << "Tried to fetch two things at once!";
 
   DVLOG(1) << "Starting IssueAuthToken for: " << service;
   requested_service_ = service;
   request_body_ = MakeIssueAuthTokenBody(sid, lsid, service);
-  fetcher_.reset(CreateGaiaFetcher(getter_,
-                                   request_body_,
-                                   std::string(),
-                                   issue_auth_token_gurl_,
-                                   kLoadFlagsIgnoreCookies,
-                                   this));
+  fetcher_ =
+      CreateGaiaFetcher(getter_, request_body_, std::string(),
+                        issue_auth_token_gurl_, kLoadFlagsIgnoreCookies, this);
   fetch_pending_ = true;
   fetcher_->Start();
 }
 
 void GaiaAuthFetcher::StartLsoForOAuthLoginTokenExchange(
     const std::string& auth_token) {
   DCHECK(!fetch_pending_) << "Tried to fetch two things at once!";
 
   DVLOG(1) << "Starting OAuth login token exchange with auth_token";
   request_body_ = MakeGetAuthCodeBody(false);
   client_login_to_oauth2_gurl_ =
       GaiaUrls::GetInstance()->client_login_to_oauth2_url();
 
-  fetcher_.reset(CreateGaiaFetcher(getter_,
-                                   request_body_,
-                                   MakeGetAuthCodeHeader(auth_token),
-                                   client_login_to_oauth2_gurl_,
-                                   kLoadFlagsIgnoreCookies,
-                                   this));
+  fetcher_ = CreateGaiaFetcher(
+      getter_, request_body_, MakeGetAuthCodeHeader(auth_token),
+      client_login_to_oauth2_gurl_, kLoadFlagsIgnoreCookies, this);
   fetch_pending_ = true;
   fetcher_->Start();
 }
 
 void GaiaAuthFetcher::StartRevokeOAuth2Token(const std::string& auth_token) {
   DCHECK(!fetch_pending_) << "Tried to fetch two things at once!";
 
   DVLOG(1) << "Starting OAuth2 token revocation";
   request_body_ = MakeRevokeTokenBody(auth_token);
-  fetcher_.reset(CreateGaiaFetcher(getter_,
-                                   request_body_,
-                                   std::string(),
-                                   oauth2_revoke_gurl_,
-                                   kLoadFlagsIgnoreCookies,
-                                   this));
+  fetcher_ =
+      CreateGaiaFetcher(getter_, request_body_, std::string(),
+                        oauth2_revoke_gurl_, kLoadFlagsIgnoreCookies, this);
   fetch_pending_ = true;
   fetcher_->Start();
 }
 
 void GaiaAuthFetcher::StartCookieForOAuthLoginTokenExchange(
     const std::string& session_index) {
   StartCookieForOAuthLoginTokenExchangeWithDeviceId(session_index,
                                                     std::string());
 }
 
@@ skipping 11 matching lines @@
     client_login_to_oauth2_gurl_ =
         client_login_to_oauth2_gurl_.Resolve("?authuser=" + session_index);
   }
 
   std::string device_id_header;
   if (!device_id.empty()) {
     device_id_header =
         base::StringPrintf(kDeviceIdHeaderFormat, device_id.c_str());
   }
 
-  fetcher_.reset(CreateGaiaFetcher(getter_,
-                                   request_body_,
-                                   device_id_header,
-                                   client_login_to_oauth2_gurl_,
-                                   net::LOAD_NORMAL,
-                                   this));
+  fetcher_ =
+      CreateGaiaFetcher(getter_, request_body_, device_id_header,
+                        client_login_to_oauth2_gurl_, net::LOAD_NORMAL, this);
   fetch_pending_ = true;
   fetcher_->Start();
 }
 
 void GaiaAuthFetcher::StartAuthCodeForOAuth2TokenExchange(
     const std::string& auth_code) {
   DCHECK(!fetch_pending_) << "Tried to fetch two things at once!";
 
   DVLOG(1) << "Starting OAuth token pair fetch";
   request_body_ = MakeGetTokenPairBody(auth_code);
-  fetcher_.reset(CreateGaiaFetcher(getter_,
-                                   request_body_,
-                                   std::string(),
-                                   oauth2_token_gurl_,
-                                   kLoadFlagsIgnoreCookies,
-                                   this));
+  fetcher_ =
+      CreateGaiaFetcher(getter_, request_body_, std::string(),
+                        oauth2_token_gurl_, kLoadFlagsIgnoreCookies, this);
   fetch_pending_ = true;
   fetcher_->Start();
 }
 
 void GaiaAuthFetcher::StartGetUserInfo(const std::string& lsid) {
   DCHECK(!fetch_pending_) << "Tried to fetch two things at once!";
 
   DVLOG(1) << "Starting GetUserInfo for lsid=" << lsid;
   request_body_ = MakeGetUserInfoBody(lsid);
-  fetcher_.reset(CreateGaiaFetcher(getter_,
-                                   request_body_,
-                                   std::string(),
-                                   get_user_info_gurl_,
-                                   kLoadFlagsIgnoreCookies,
-                                   this));
+  fetcher_ =
+      CreateGaiaFetcher(getter_, request_body_, std::string(),
+                        get_user_info_gurl_, kLoadFlagsIgnoreCookies, this);
   fetch_pending_ = true;
   fetcher_->Start();
 }
 
 void GaiaAuthFetcher::StartMergeSession(const std::string& uber_token,
                                         const std::string& external_cc_result) {
   DCHECK(!fetch_pending_) << "Tried to fetch two things at once!";
 
   DVLOG(1) << "Starting MergeSession with uber_token=" << uber_token;
 
   // The continue URL is a required parameter of the MergeSession API, but in
   // this case we don't actually need or want to navigate to it.  Setting it to
   // an arbitrary Google URL.
   //
   // In order for the new session to be merged correctly, the server needs to
   // know what sessions already exist in the browser.  The fetcher needs to be
   // created such that it sends the cookies with the request, which is
   // different from all other requests the fetcher can make.
   std::string continue_url("http://www.google.com");
   request_body_ = MakeMergeSessionBody(uber_token, external_cc_result,
       continue_url, source_);
-  fetcher_.reset(CreateGaiaFetcher(getter_,
-                                   request_body_,
-                                   std::string(),
-                                   merge_session_gurl_,
-                                   net::LOAD_NORMAL,
-                                   this));
+  fetcher_ = CreateGaiaFetcher(getter_, request_body_, std::string(),
+                               merge_session_gurl_, net::LOAD_NORMAL, this);
   fetch_pending_ = true;
   fetcher_->Start();
 }
 
 void GaiaAuthFetcher::StartTokenFetchForUberAuthExchange(
     const std::string& access_token) {
   DCHECK(!fetch_pending_) << "Tried to fetch two things at once!";
 
   DVLOG(1) << "Starting StartTokenFetchForUberAuthExchange with access_token="
            << access_token;
   std::string authentication_header =
       base::StringPrintf(kOAuthHeaderFormat, access_token.c_str());
-  fetcher_.reset(CreateGaiaFetcher(getter_,
-                                   std::string(),
-                                   authentication_header,
-                                   uberauth_token_gurl_,
-                                   net::LOAD_NORMAL,
-                                   this));
+  fetcher_ = CreateGaiaFetcher(getter_, std::string(), authentication_header,
+                               uberauth_token_gurl_, net::LOAD_NORMAL, this);
   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(kOAuth2BearerHeaderFormat, access_token.c_str());
-  fetcher_.reset(CreateGaiaFetcher(getter_,
-                                   request_body_,
-                                   authentication_header,
-                                   oauth_login_gurl_,
-                                   net::LOAD_NORMAL,
-                                   this));
+  fetcher_ = CreateGaiaFetcher(getter_, request_body_, authentication_header,
+                               oauth_login_gurl_, net::LOAD_NORMAL, this);
   fetch_pending_ = true;
   fetcher_->Start();
 }
 
 void GaiaAuthFetcher::StartListAccounts() {
   DCHECK(!fetch_pending_) << "Tried to fetch two things at once!";
 
-  fetcher_.reset(CreateGaiaFetcher(getter_,
-                                   " ",  // To force an HTTP POST.
-                                   "Origin: https://www.google.com",
-                                   list_accounts_gurl_,
-                                   net::LOAD_NORMAL,
-                                   this));
+  fetcher_ = CreateGaiaFetcher(getter_,
+                               " ",  // To force an HTTP POST.
+                               "Origin: https://www.google.com",
+                               list_accounts_gurl_, net::LOAD_NORMAL, this);
   fetch_pending_ = true;
   fetcher_->Start();
 }
 
 void GaiaAuthFetcher::StartGetCheckConnectionInfo() {
   DCHECK(!fetch_pending_) << "Tried to fetch two things at once!";
 
-  fetcher_.reset(CreateGaiaFetcher(getter_,
-                                   std::string(),
-                                   std::string(),
-                                   get_check_connection_info_url_,
-                                   kLoadFlagsIgnoreCookies,
-                                   this));
+  fetcher_ = CreateGaiaFetcher(getter_, std::string(), std::string(),
+                               get_check_connection_info_url_,
+                               kLoadFlagsIgnoreCookies, this);
   fetch_pending_ = true;
   fetcher_->Start();
 }
 
 void GaiaAuthFetcher::StartListIDPSessions(const std::string& scopes,
                                            const std::string& domain) {
   DCHECK(!fetch_pending_) << "Tried to fetch two things at once!";
 
   request_body_ = MakeListIDPSessionsBody(scopes, domain);
-  fetcher_.reset(CreateGaiaFetcher(getter_,
-                                   request_body_,
-                                   std::string(),
-                                   oauth2_iframe_url_,
-                                   net::LOAD_NORMAL,
-                                   this));
+  fetcher_ = CreateGaiaFetcher(getter_, request_body_, std::string(),
+                               oauth2_iframe_url_, net::LOAD_NORMAL, this);
   requested_service_ = kListIdpServiceRequested;
   fetch_pending_ = true;
   fetcher_->Start();
 }
 
 void GaiaAuthFetcher::StartGetTokenResponse(const std::string& scopes,
                                             const std::string& domain,
                                             const std::string& login_hint) {
   DCHECK(!fetch_pending_) << "Tried to fetch two things at once!";
 
   request_body_ = MakeGetTokenResponseBody(scopes, domain, login_hint);
-  fetcher_.reset(CreateGaiaFetcher(getter_,
-                                   request_body_,
-                                   std::string(),
-                                   oauth2_iframe_url_,
-                                   net::LOAD_NORMAL,
-                                   this));
+  fetcher_ = CreateGaiaFetcher(getter_, request_body_, std::string(),
+                               oauth2_iframe_url_, net::LOAD_NORMAL, this);
 
   requested_service_ = kGetTokenResponseRequested;
   fetch_pending_ = true;
   fetcher_->Start();
 }
 
 // static
 GoogleServiceAuthError GaiaAuthFetcher::GenerateAuthError(
     const std::string& data,
     const net::URLRequestStatus& status) {
@@ skipping 301 matching lines @@
   return alleged_error.find(kSecondFactor) !=
       std::string::npos;
 }
 
 // static
 bool GaiaAuthFetcher::IsWebLoginRequiredSuccess(
     const std::string& alleged_error) {
   return alleged_error.find(kWebLoginRequired) !=
       std::string::npos;
 }