Create a content::UrlFetcher interface that lives in content/public/common and convert users to i...

chrome/browser/chromeos/login/mock_url_fetchers.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/chromeos/login/mock_url_fetchers.h"
 
 #include <errno.h>
 
 #include "base/bind.h"
 #include "base/message_loop.h"
@@ skipping 42 matching lines @@
       url_(url),
       status_(net::URLRequestStatus::CANCELED, 0) {
 }
 
 GotCanceledFetcher::~GotCanceledFetcher() {}
 
 void GotCanceledFetcher::Start() {
   delegate()->OnURLFetchComplete(this);
 }
 
-const GURL& GotCanceledFetcher::url() const {
+const GURL& GotCanceledFetcher::GetUrl() const {
   return url_;
 }
 
-const net::URLRequestStatus& GotCanceledFetcher::status() const {
+const net::URLRequestStatus& GotCanceledFetcher::GetStatus() const {
   return status_;
 }
 
-int GotCanceledFetcher::response_code() const {
+int GotCanceledFetcher::GetResponseCode() const {
   return RC_FORBIDDEN;
 }
 
 SuccessFetcher::SuccessFetcher(bool success,
                                const GURL& url,
                                const std::string& results,
                                URLFetcher::RequestType request_type,
                                content::URLFetcherDelegate* d)
     : URLFetcher(url, request_type, d),
       url_(url),
       status_(net::URLRequestStatus::SUCCESS, 0) {
 }
 
 SuccessFetcher::~SuccessFetcher() {}
 
 void SuccessFetcher::Start() {
   delegate()->OnURLFetchComplete(this);
 }
 
-const GURL& SuccessFetcher::url() const {
+const GURL& SuccessFetcher::GetUrl() const {
   return url_;
 }
 
-const net::URLRequestStatus& SuccessFetcher::status() const {
+const net::URLRequestStatus& SuccessFetcher::GetStatus() const {
   return status_;
 }
 
-int SuccessFetcher::response_code() const {
+int SuccessFetcher::GetResponseCode() const {
   return RC_REQUEST_OK;
 }
 
 FailFetcher::FailFetcher(bool success,
                          const GURL& url,
                          const std::string& results,
                          URLFetcher::RequestType request_type,
                          content::URLFetcherDelegate* d)
     : URLFetcher(url, request_type, d),
       url_(url),
       status_(net::URLRequestStatus::FAILED, ECONNRESET) {
 }
 
 FailFetcher::~FailFetcher() {}
 
 void FailFetcher::Start() {
   delegate()->OnURLFetchComplete(this);
 }
 
-const GURL& FailFetcher::url() const {
+const GURL& FailFetcher::GetUrl() const {
   return url_;
 }
 
-const net::URLRequestStatus& FailFetcher::status() const {
+const net::URLRequestStatus& FailFetcher::GetStatus() const {
   return status_;
 }
 
-int FailFetcher::response_code() const {
+int FailFetcher::GetResponseCode() const {
   return RC_REQUEST_OK;
 }
 
 // static
 const char CaptchaFetcher::kCaptchaToken[] = "token";
 // static
 const char CaptchaFetcher::kCaptchaUrlBase[] = "http://www.google.com/accounts/";
 // static
 const char CaptchaFetcher::kCaptchaUrlFragment[] = "fragment";
 // static
@@ skipping 32 matching lines @@
 
 // static
 std::string CaptchaFetcher::GetUnlockUrl() {
   return kUnlockUrl;
 }
 
 void CaptchaFetcher::Start() {
   delegate()->OnURLFetchComplete(this);
 }
 
-const GURL& CaptchaFetcher::url() const {
+const GURL& CaptchaFetcher::GetUrl() const {
   return url_;
 }
 
-const net::URLRequestStatus& CaptchaFetcher::status() const {
+const net::URLRequestStatus& CaptchaFetcher::GetStatus() const {
   return status_;
 }
 
-int CaptchaFetcher::response_code() const {
+int CaptchaFetcher::GetResponseCode() const {
   return RC_FORBIDDEN;
 }
 
 bool CaptchaFetcher::GetResponseAsString(
     std::string* out_response_string) const {
   *out_response_string = data_;
   return true;
 }
 
 HostedFetcher::HostedFetcher(bool success,
@@ skipping 12 matching lines @@
 void HostedFetcher::Start() {
   VLOG(1) << upload_data();
   if (upload_data().find("HOSTED") == std::string::npos) {
     VLOG(1) << "HostedFetcher failing request";
     response_code_ = RC_FORBIDDEN;
     data_.assign("Error=BadAuthentication");
   }
   delegate()->OnURLFetchComplete(this);
 }
 
-const GURL& HostedFetcher::url() const {
+const GURL& HostedFetcher::GetUrl() const {
   return url_;
 }
 
-const net::URLRequestStatus& HostedFetcher::status() const {
+const net::URLRequestStatus& HostedFetcher::GetStatus() const {
   return status_;
 }
 
-int HostedFetcher::response_code() const {
+int HostedFetcher::GetResponseCode() const {
   return response_code_;;
 }
 
 bool HostedFetcher::GetResponseAsString(
     std::string* out_response_string) const {
   *out_response_string = data_;
   return true;
 }
 
 }  // namespace chromeos