Implement support for fallback update check urls in the component updater

components/component_updater/test/url_request_post_interceptor.cc

 // Copyright 2013 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 "components/component_updater/test/url_request_post_interceptor.h"
 
 #include "base/files/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/stringprintf.h"
 #include "components/component_updater/test/test_configurator.h"
 #include "net/base/upload_bytes_element_reader.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_filter.h"
 #include "net/url_request/url_request_interceptor.h"
 #include "net/url_request/url_request_simple_job.h"
 #include "net/url_request/url_request_test_util.h"
 
 namespace component_updater {
 
 // Returns a canned response.
 class URLRequestMockJob : public net::URLRequestSimpleJob {
  public:
   URLRequestMockJob(net::URLRequest* request,
                     net::NetworkDelegate* network_delegate,
-                    const std::string& response)
+                    int response_code,
+                    const std::string& response_body)
       : net::URLRequestSimpleJob(request, network_delegate),
-        response_(response) {}
+        response_code_(response_code),
+        response_body_(response_body) {}
 
  protected:
-  virtual int GetResponseCode() const OVERRIDE { return 200; }
+  virtual int GetResponseCode() const OVERRIDE { return response_code_; }
 
   virtual int GetData(std::string* mime_type,
                       std::string* charset,
                       std::string* data,
                       const net::CompletionCallback& callback) const OVERRIDE {
     mime_type->assign("text/plain");
     charset->assign("US-ASCII");
-    data->assign(response_);
+    data->assign(response_body_);
     return net::OK;
   }
 
  private:
   virtual ~URLRequestMockJob() {}
 
-  std::string response_;
+  int response_code_;
+  std::string response_body_;
   DISALLOW_COPY_AND_ASSIGN(URLRequestMockJob);
 };
 
 URLRequestPostInterceptor::URLRequestPostInterceptor(
     const GURL& url,
     const scoped_refptr<base::SequencedTaskRunner>& io_task_runner)
     : url_(url), io_task_runner_(io_task_runner), hit_count_(0) {
 }
 
 URLRequestPostInterceptor::~URLRequestPostInterceptor() {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
   ClearExpectations();
 }
 
 void URLRequestPostInterceptor::ClearExpectations() {
   while (!expectations_.empty()) {
     Expectation expectation(expectations_.front());
     delete expectation.first;
     expectations_.pop();
   }
 }
 
 GURL URLRequestPostInterceptor::GetUrl() const {
   return url_;
 }
 
 bool URLRequestPostInterceptor::ExpectRequest(
     class RequestMatcher* request_matcher) {
-  expectations_.push(std::make_pair(request_matcher, ""));
+  expectations_.push(std::make_pair(request_matcher,
+                                    ExpectationResponse(kResponseCode200, "")));
   return true;
 }
 
+bool URLRequestPostInterceptor::ExpectRequest(
+    class RequestMatcher* request_matcher,
+    int response_code) {
+  expectations_.push(
+      std::make_pair(request_matcher, ExpectationResponse(response_code, "")));
+  return true;
+}
+
 bool URLRequestPostInterceptor::ExpectRequest(
     class RequestMatcher* request_matcher,
     const base::FilePath& filepath) {
   std::string response;
   if (filepath.empty() || !base::ReadFileToString(filepath, &response))
     return false;
-  expectations_.push(std::make_pair(request_matcher, response));
+
+  expectations_.push(std::make_pair(
+      request_matcher, ExpectationResponse(kResponseCode200, response)));
   return true;
 }
 
 int URLRequestPostInterceptor::GetHitCount() const {
   base::AutoLock auto_lock(interceptor_lock_);
   return hit_count_;
 }
 
 int URLRequestPostInterceptor::GetCount() const {
   base::AutoLock auto_lock(interceptor_lock_);
@@ skipping 45 matching lines @@
     for (InterceptorMap::iterator it = interceptors_.begin();
          it != interceptors_.end();
          ++it)
       delete (*it).second;
     net::URLRequestFilter::GetInstance()->RemoveHostnameHandler(scheme_,
                                                                 hostname_);
   }
 
   void OnCreateInterceptor(URLRequestPostInterceptor* interceptor) {
     DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
-    CHECK(interceptors_.find(interceptor->GetUrl()) == interceptors_.end());
+    DCHECK(interceptors_.find(interceptor->GetUrl()) == interceptors_.end());
 
     interceptors_.insert(std::make_pair(interceptor->GetUrl(), interceptor));
   }
 
  private:
   virtual ~Delegate() {}
 
   virtual net::URLRequestJob* MaybeInterceptRequest(
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate) const OVERRIDE {
@@ skipping 28 matching lines @@
     const std::string request_body(reader->bytes());
 
     {
       base::AutoLock auto_lock(interceptor->interceptor_lock_);
       interceptor->requests_.push_back(request_body);
       if (interceptor->expectations_.empty())
         return NULL;
       const URLRequestPostInterceptor::Expectation& expectation(
           interceptor->expectations_.front());
       if (expectation.first->Match(request_body)) {
-        const std::string response(expectation.second);
+        const int response_code(expectation.second.response_code);
+        const std::string response_body(expectation.second.response_body);
         delete expectation.first;
         interceptor->expectations_.pop();
         ++interceptor->hit_count_;
 
-        return new URLRequestMockJob(request, network_delegate, response);
+        return new URLRequestMockJob(
+            request, network_delegate, response_code, response_body);
       }
     }
 
     return NULL;
   }
 
   typedef std::map<GURL, URLRequestPostInterceptor*> InterceptorMap;
   InterceptorMap interceptors_;
 
   const std::string scheme_;
@@ skipping 54 matching lines @@
     const scoped_refptr<base::SequencedTaskRunner>& io_task_runner)
     : URLRequestPostInterceptorFactory(POST_INTERCEPT_SCHEME,
                                        POST_INTERCEPT_HOSTNAME,
                                        io_task_runner) {
 }
 
 InterceptorFactory::~InterceptorFactory() {
 }
 
 URLRequestPostInterceptor* InterceptorFactory::CreateInterceptor() {
+  return CreateInterceptorForPath(POST_INTERCEPT_PATH);
+}
+
+URLRequestPostInterceptor* InterceptorFactory::CreateInterceptorForPath(
+    const char* url_path) {
   return URLRequestPostInterceptorFactory::CreateInterceptor(
-      base::FilePath::FromUTF8Unsafe(POST_INTERCEPT_PATH));
+      base::FilePath::FromUTF8Unsafe(url_path));
 }
 
 }  // namespace component_updater