net: Remove typedef net::URLRequestStatus URLRequestStatus;

chrome/common/net/gaia/gaia_auth_fetcher.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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/common/net/gaia/gaia_auth_fetcher.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/string_split.h"
@@ skipping 295 matching lines @@
                                    get_user_info_gurl_,
                                    this));
   fetch_pending_ = true;
   requested_info_key_ = info_key;
   fetcher_->Start();
 }
 
 // static
 GoogleServiceAuthError GaiaAuthFetcher::GenerateAuthError(
     const std::string& data,
-    const URLRequestStatus& status) {
+    const net::URLRequestStatus& status) {
 
   if (!status.is_success()) {
-    if (status.status() == URLRequestStatus::CANCELED) {
+    if (status.status() == net::URLRequestStatus::CANCELED) {
       return GoogleServiceAuthError(GoogleServiceAuthError::REQUEST_CANCELED);
     } else {
       LOG(WARNING) << "Could not reach Google Accounts servers: errno "
           << status.os_error();
       return GoogleServiceAuthError::FromConnectionError(status.os_error());
     }
   } else {
     if (IsSecondFactorSuccess(data)) {
       return GoogleServiceAuthError(GoogleServiceAuthError::TWO_FACTOR);
     }
@@ skipping 26 matching lines @@
 
     LOG(WARNING) << "Incomprehensible response from Google Accounts servers.";
     return GoogleServiceAuthError(
         GoogleServiceAuthError::SERVICE_UNAVAILABLE);
   }
 
   NOTREACHED();
 }
 
 void GaiaAuthFetcher::OnClientLoginFetched(const std::string& data,
-                                           const URLRequestStatus& status,
+                                           const net::URLRequestStatus& status,
                                            int response_code) {
 
   if (status.is_success() && response_code == RC_REQUEST_OK) {
     VLOG(1) << "ClientLogin successful!";
     std::string sid;
     std::string lsid;
     std::string token;
     ParseClientLoginResponse(data, &sid, &lsid, &token);
     consumer_->OnClientLoginSuccess(
         GaiaAuthConsumer::ClientLoginResult(sid, lsid, token, data));
   } else {
     consumer_->OnClientLoginFailure(GenerateAuthError(data, status));
   }
 }
 
 void GaiaAuthFetcher::OnIssueAuthTokenFetched(
     const std::string& data,
-    const URLRequestStatus& status,
+    const net::URLRequestStatus& status,
     int response_code) {
   if (status.is_success() && response_code == RC_REQUEST_OK) {
     // Only the bare token is returned in the body of this Gaia call
     // without any padding.
     consumer_->OnIssueAuthTokenSuccess(requested_service_, data);
   } else {
     consumer_->OnIssueAuthTokenFailure(requested_service_,
         GenerateAuthError(data, status));
   }
 }
 
 void GaiaAuthFetcher::OnGetUserInfoFetched(
     const std::string& data,
-    const URLRequestStatus& status,
+    const net::URLRequestStatus& status,
     int response_code) {
   using std::vector;
   using std::string;
   using std::pair;
 
   if (status.is_success() && response_code == RC_REQUEST_OK) {
     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 == requested_info_key_) {
         consumer_->OnGetUserInfoSuccess(i->first, i->second);
         return;
       }
     }
     consumer_->OnGetUserInfoKeyNotFound(requested_info_key_);
   } else {
     consumer_->OnGetUserInfoFailure(GenerateAuthError(data, status));
   }
 }
 
 void GaiaAuthFetcher::OnURLFetchComplete(const URLFetcher* source,
                                          const GURL& url,
-                                         const URLRequestStatus& status,
+                                         const net::URLRequestStatus& status,
                                          int response_code,
                                          const ResponseCookies& cookies,
                                          const std::string& data) {
   fetch_pending_ = false;
   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 == get_user_info_gurl_) {
     OnGetUserInfoFetched(data, status, response_code);
   } else {
     NOTREACHED();
   }
 }
 
 // static
 bool GaiaAuthFetcher::IsSecondFactorSuccess(
     const std::string& alleged_error) {
   return alleged_error.find(kSecondFactor) !=
       std::string::npos;
 }