Make test URLFetcher implementations not derive from the URLFetcher implementation, since we want...

chrome/browser/policy/testing_policy_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 "chrome/browser/policy/testing_policy_url_fetcher_factory.h"
 
 #include "base/bind.h"
 #include "chrome/browser/policy/logging_work_scheduler.h"
 #include "googleurl/src/gurl.h"
 #include "googleurl/src/url_parse.h"
@@ skipping 16 matching lines @@
     }
   }
   return "";
 }
 
 }  // namespace
 
 namespace policy {
 
 // An URLFetcher that calls back to its factory to figure out what to respond.
-class TestingPolicyURLFetcher : public URLFetcher {
+class TestingPolicyURLFetcher : public TestURLFetcher {
  public:
   TestingPolicyURLFetcher(
       const base::WeakPtr<TestingPolicyURLFetcherFactory>& parent,
       const GURL& url,
-      URLFetcher::RequestType request_type,
+      content::URLFetcher::RequestType request_type,
       content::URLFetcherDelegate* delegate);
 
   virtual void Start() OVERRIDE;
   void Respond();
 
-  virtual const GURL& GetUrl() const OVERRIDE {
-    return url_;
-  }
-
-  virtual const net::URLRequestStatus& GetStatus() const OVERRIDE {
-    return status_;
-  }
-
   virtual int GetResponseCode() const OVERRIDE {
     return response_.response_code;
   }
 
   virtual bool GetResponseAsString(
       std::string* out_response_string) const OVERRIDE {
     *out_response_string = response_.response_data;
     return true;
   }
 
  private:
-  GURL url_;
-  net::URLRequestStatus status_;
   TestURLResponse response_;
   base::WeakPtr<TestingPolicyURLFetcherFactory> parent_;
 
   DISALLOW_COPY_AND_ASSIGN(TestingPolicyURLFetcher);
 };
 
 TestingPolicyURLFetcher::TestingPolicyURLFetcher(
     const base::WeakPtr<TestingPolicyURLFetcherFactory>& parent,
     const GURL& url,
-    URLFetcher::RequestType request_type,
+    content::URLFetcher::RequestType request_type,
     content::URLFetcherDelegate* delegate)
-        : URLFetcher(url, request_type, delegate),
-          url_(url),
-          status_(net::URLRequestStatus::SUCCESS, 0),
-          parent_(parent) {
+    : TestURLFetcher(0, url, request_type, delegate),
+      parent_(parent) {
+  set_url(url);
+  set_status(net::URLRequestStatus(net::URLRequestStatus::SUCCESS, 0));
 }
 
 void TestingPolicyURLFetcher::Start() {
   if (!parent_.get()) return;
 
   std::string auth_header;
   net::HttpRequestHeaders headers;
-  std::string request = GetRequestType(url_);
+  std::string request = GetRequestType(GetUrl());
   GetExtraRequestHeaders(&headers);
   headers.GetHeader("Authorization", &auth_header);
   // The following method is mocked by the currently running test.
   parent_->GetResponse(auth_header, request, &response_);
 
   // We need to channel this through the central event logger, so that ordering
   // with other logged tasks that have a delay is preserved.
   parent_->scheduler()->PostDelayedWork(
       base::Bind(&TestingPolicyURLFetcher::Respond, base::Unretained(this)),
       0);
@@ skipping 19 matching lines @@
 }
 
 void TestingPolicyURLFetcherFactory::GetResponse(
     const std::string& auth_header,
     const std::string& request,
     TestURLResponse* response) {
   logger_->RegisterEvent();
   Intercept(auth_header, request, response);
 }
 
-URLFetcher* TestingPolicyURLFetcherFactory::CreateURLFetcher(
+content::URLFetcher* TestingPolicyURLFetcherFactory::CreateURLFetcher(
     int id,
     const GURL& url,
-    URLFetcher::RequestType request_type,
+    content::URLFetcher::RequestType request_type,
     content::URLFetcherDelegate* delegate) {
   return new TestingPolicyURLFetcher(
       weak_ptr_factory_.GetWeakPtr(), url, request_type, delegate);
 }
 
 }  // namespace policy