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

content/test/test_url_fetcher_factory.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 "content/test/test_url_fetcher_factory.h"
 
 #include <string>
 
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
@@ skipping 24 matching lines @@
 TestURLFetcher::~TestURLFetcher() {
 }
 
 void TestURLFetcher::AppendChunkToUpload(const std::string& data,
                                          bool is_last_chunk) {
   DCHECK(!did_receive_last_chunk_);
   did_receive_last_chunk_ = is_last_chunk;
   chunks_.push_back(data);
 }
 
-const GURL& TestURLFetcher::original_url() const {
+const GURL& TestURLFetcher::GetOriginalUrl() const {
   return original_url_;
 }
 
 void TestURLFetcher::set_status(const net::URLRequestStatus& status) {
   fake_status_ = status;
 }
 
 void TestURLFetcher::set_was_fetched_via_proxy(bool flag) {
   URLFetcher::set_was_fetched_via_proxy(flag);
 }
@@ skipping 51 matching lines @@
   Fetchers::const_iterator i = fetchers_.find(id);
   return i == fetchers_.end() ? NULL : i->second;
 }
 
 void TestURLFetcherFactory::RemoveFetcherFromMap(int id) {
   Fetchers::iterator i = fetchers_.find(id);
   DCHECK(i != fetchers_.end());
   fetchers_.erase(i);
 }
 
-const GURL& TestURLFetcher::url() const {
+const GURL& TestURLFetcher::GetUrl() const {
   return fake_url_;
 }
 
-const net::URLRequestStatus& TestURLFetcher::status() const {
+const net::URLRequestStatus& TestURLFetcher::GetStatus() const {
   return fake_status_;
 }
 
-int TestURLFetcher::response_code() const {
+int TestURLFetcher::GetResponseCode() const {
   return fake_response_code_;
 }
 
-const net::ResponseCookies& TestURLFetcher::cookies() const {
+const net::ResponseCookies& TestURLFetcher::GetCookies() const {
   return fake_cookies_;
 }
 
 // This class is used by the FakeURLFetcherFactory below.
 class FakeURLFetcher : public URLFetcher {
  public:
   // Normal URL fetcher constructor but also takes in a pre-baked response.
   FakeURLFetcher(const GURL& url, RequestType request_type,
                  content::URLFetcherDelegate* d,
                  const std::string& response_data, bool success)
     : URLFetcher(url, request_type, d),
       url_(url),
       response_data_(response_data),
       success_(success),
       status_(success ? net::URLRequestStatus::SUCCESS :
                         net::URLRequestStatus::FAILED, 0),
       ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)) {
   }
 
   // Start the request.  This will call the given delegate asynchronously
   // with the pre-baked response as parameter.
   virtual void Start() OVERRIDE {
     MessageLoop::current()->PostTask(
         FROM_HERE,
         method_factory_.NewRunnableMethod(&FakeURLFetcher::RunDelegate));
   }
 
   // These methods are overriden so we can use the version of
   // OnURLFetchComplete that only has a single URLFetcher argument.
-  virtual const net::ResponseCookies& cookies() const OVERRIDE {
+  virtual const net::ResponseCookies& GetCookies() const OVERRIDE {
     return cookies_;
   }
 
   virtual bool GetResponseAsString(
       std::string* out_response_string) const OVERRIDE {
     *out_response_string = response_data_;
     return true;
   }
 
-  virtual int response_code() const OVERRIDE {
+  virtual int GetResponseCode() const OVERRIDE {
     return success_ ? 200 : 500;
   }
 
-  virtual const net::URLRequestStatus& status() const OVERRIDE {
+  virtual const net::URLRequestStatus& GetStatus() const OVERRIDE {
     return status_;
   }
 
-  virtual const GURL& url() const OVERRIDE {
+  virtual const GURL& GetUrl() const OVERRIDE {
     return url_;
   }
 
  private:
   virtual ~FakeURLFetcher() {
   }
 
   // This is the method which actually calls the delegate that is passed in the
   // constructor.
   void RunDelegate() {
@@ skipping 60 matching lines @@
 
 URLFetcherFactory::~URLFetcherFactory() {}
 
 URLFetcher* URLFetcherFactory::CreateURLFetcher(
     int id,
     const GURL& url,
     URLFetcher::RequestType request_type,
     content::URLFetcherDelegate* d) {
   return new URLFetcher(url, request_type, d);
 }