Rewrite std::string("") to std::string(), Linux edition.

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>
@@ skipping 599 matching lines @@
   // 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));
   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));
   fetch_pending_ = true;
   fetcher_->Start();
 }
 
 void GaiaAuthFetcher::StartLsoForOAuthLoginTokenExchange(
     const std::string& auth_token) {
   DCHECK(!fetch_pending_) << "Tried to fetch two things at once!";
@@ skipping 13 matching lines @@
   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));
   fetch_pending_ = true;
   fetcher_->Start();
 }
 
 void GaiaAuthFetcher::StartCookieForOAuthLoginTokenExchange(
     const std::string& session_index) {
   DCHECK(!fetch_pending_) << "Tried to fetch two things at once!";
 
   DVLOG(1) << "Starting OAuth login token fetch with cookie jar";
   request_body_ = MakeGetAuthCodeBody();
 
   std::string url = GaiaUrls::GetInstance()->client_login_to_oauth2_url();
   if (!session_index.empty())
     url += "?authuser=" + session_index;
 
   client_login_to_oauth2_gurl_ = GURL(url);
 
   fetcher_.reset(CreateGaiaFetcher(getter_,
                                    request_body_,
-                                   "",
+                                   std::string(),
                                    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));
   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));
   fetch_pending_ = true;
   fetcher_->Start();
 }
 
 void GaiaAuthFetcher::StartMergeSession(const std::string& uber_token) {
   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, continue_url, source_);
   fetcher_.reset(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_,
                                    kLoadFlagsIgnoreCookies,
                                    this));
   fetch_pending_ = true;
   fetcher_->Start();
 }
 
 void GaiaAuthFetcher::StartClientOAuth(const std::string& username,
                                        const std::string& password,
                                        const std::vector<std::string>& scopes,
                                        const std::string& persistent_id,
                                        const std::string& locale) {
   DCHECK(!fetch_pending_) << "Tried to fetch two things at once!";
 
   request_body_ = MakeClientOAuthBody(username, password, scopes, persistent_id,
                                       source_, locale);
   fetcher_.reset(CreateGaiaFetcher(getter_,
                                    request_body_,
-                                   "",
+                                   std::string(),
                                    client_oauth_gurl_,
                                    kLoadFlagsIgnoreCookies,
                                    this));
   fetch_pending_ = true;
   fetcher_->Start();
 }
 
 void GaiaAuthFetcher::StartClientOAuthChallengeResponse(
     GoogleServiceAuthError::State type,
     const std::string& token,
     const std::string& solution) {
   DCHECK(!fetch_pending_) << "Tried to fetch two things at once!";
 
   std::string name;
   switch (type) {
     case GoogleServiceAuthError::CAPTCHA_REQUIRED:
       name = kCaptcha;
       break;
     case GoogleServiceAuthError::TWO_FACTOR:
       name = kTwoFactor;
       break;
     default:
       NOTREACHED();
   }
 
   request_body_ = MakeClientOAuthChallengeResponseBody(name, token, solution);
   fetcher_.reset(CreateGaiaFetcher(getter_,
                                    request_body_,
-                                   "",
+                                   std::string(),
                                    client_oauth_gurl_,
                                    kLoadFlagsIgnoreCookies,
                                    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!";
@@ skipping 329 matching lines @@
     NOTREACHED();
   }
 }
 
 // static
 bool GaiaAuthFetcher::IsSecondFactorSuccess(
     const std::string& alleged_error) {
   return alleged_error.find(kSecondFactor) !=
       std::string::npos;
 }