Add support to download web store promo logos over https.

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 107 matching lines @@
 // 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, Delegate* 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() {
+  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 {
+    return cookies_;
+  }
+
+  virtual const std::string& GetResponseStringRef() const OVERRIDE {
+    return response_data_;
+  }
+
+  virtual bool GetResponseAsString(
+      std::string* out_response_string) const OVERRIDE {
+    *out_response_string = response_data_;
+    return true;
+  }
+
+  virtual int response_code() const OVERRIDE {
+    return success_ ? 200 : 500;
+  }
+
+  virtual const net::URLRequestStatus& status() const OVERRIDE {
+    return status_;
+  }
+
+  virtual const GURL& url() const OVERRIDE {
+    return url_;
+  }
+
  private:
   virtual ~FakeURLFetcher() {
   }
 
   // This is the method which actually calls the delegate that is passed in the
   // constructor.
   void RunDelegate() {
-    net::URLRequestStatus status;
-    status.set_status(success_ ? net::URLRequestStatus::SUCCESS :
-                                 net::URLRequestStatus::FAILED);
-    delegate()->OnURLFetchComplete(this, url_, status, success_ ? 200 : 500,
-                                   net::ResponseCookies(), response_data_);
+    delegate()->OnURLFetchComplete(this);
   }
 
   // Pre-baked response data and flag which indicates whether the request should
   // be successful or not.
   GURL url_;
   std::string response_data_;
   bool success_;
+  net::URLRequestStatus status_;
+  net::ResponseCookies cookies_;
 
   // Method factory used to run the delegate.
   ScopedRunnableMethodFactory<FakeURLFetcher> method_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeURLFetcher);
 };
 
 FakeURLFetcherFactory::FakeURLFetcherFactory()
     : ScopedURLFetcherFactory(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
 }
@@ skipping 25 matching lines @@
                             it->second.first, it->second.second);
 }
 
 void FakeURLFetcherFactory::SetFakeResponse(const std::string& url,
                                             const std::string& response_data,
                                             bool success) {
   // Overwrite existing URL if it already exists.
   fake_responses_[GURL(url)] = std::make_pair(response_data, success);
 }
 
-void FakeURLFetcherFactory::ClearFakeReponses() {
+void FakeURLFetcherFactory::ClearFakeResponses() {
   fake_responses_.clear();
 }
 
 URLFetcherFactory::URLFetcherFactory() {}
 
 URLFetcherFactory::~URLFetcherFactory() {}
 
 URLFetcher* URLFetcherFactory::CreateURLFetcher(
     int id,
     const GURL& url,
     URLFetcher::RequestType request_type,
     URLFetcher::Delegate* d) {
   return new URLFetcher(url, request_type, d);
 }