Changed the update protocol for component updater from v2 to v3.

chrome/browser/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 "chrome/browser/component_updater/test/url_request_post_interceptor.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/stringprintf.h"
 #include "content/public/test/test_browser_thread.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_job_factory.h"
 #include "net/url_request/url_request_simple_job.h"
 #include "net/url_request/url_request_test_util.h"
 
 using content::BrowserThread;
 
 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)
       : net::URLRequestSimpleJob(request, network_delegate),
         response_(response) {}
 
  protected:
+  virtual int GetResponseCode() const OVERRIDE {
+    return 200;
+  }
+
   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_);
     return net::OK;
   }
 
  private:
   virtual ~URLRequestMockJob() {}
 
   std::string response_;
   DISALLOW_COPY_AND_ASSIGN(URLRequestMockJob);
 };
 
 URLRequestPostInterceptor::URLRequestPostInterceptor(const GURL& url)
-    : url_(url), hit_count_(0), miss_count_(0) {}
+    : url_(url), hit_count_(0) {}
 
 URLRequestPostInterceptor::~URLRequestPostInterceptor() {
+  CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  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, ""));
   return true;
 }
 
 bool URLRequestPostInterceptor::ExpectRequest(
     class RequestMatcher* request_matcher,
-    const std::string& filepath) {
+    const base::FilePath& filepath) {
   std::string response;
-  const base::FilePath path(base::FilePath().AppendASCII(filepath));
-  if (filepath.empty() || !base::ReadFileToString(path, &response))
+  if (filepath.empty() || !base::ReadFileToString(filepath, &response))
     return false;
   expectations_.push(std::make_pair(request_matcher, response));
   return true;
 }
 
 int URLRequestPostInterceptor::GetHitCount() const {
   base::AutoLock auto_lock(interceptor_lock_);
   return hit_count_;
 }
 
-int URLRequestPostInterceptor::GetMissCount() const {
+int URLRequestPostInterceptor::GetCount() const {
   base::AutoLock auto_lock(interceptor_lock_);
-  return requests_.size() - hit_count_;
+  return static_cast<int>(requests_.size());
 }
 
 std::vector<std::string>
 URLRequestPostInterceptor::GetRequests() const {
  base::AutoLock auto_lock(interceptor_lock_);
  return requests_;
 }
 
 std::string URLRequestPostInterceptor::GetRequestsAsString() const {
   std::vector<std::string> requests(GetRequests());
 
   std::string s = "Requests are:";
 
   int i = 0;
   for (std::vector<std::string>::const_iterator it = requests.begin();
       it != requests.end(); ++it) {
     s.append(base::StringPrintf("\n  (%d): %s", ++i, it->c_str()));
   }
 
   return s;
 }
 
+void URLRequestPostInterceptor::Reset() {
+  base::AutoLock auto_lock(interceptor_lock_);
+  hit_count_ = 0;
+  requests_.clear();
+  ClearExpectations();
+}
+
 
 class URLRequestPostInterceptor::Delegate
     : public net::URLRequestJobFactory::ProtocolHandler {
  public:
   Delegate(const std::string& scheme, const std::string& hostname)
       : scheme_(scheme), hostname_(hostname) {}
 
   void Register() {
     CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
     net::URLRequestFilter::GetInstance()->AddHostnameProtocolHandler(
@@ skipping 54 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);
         delete expectation.first;
         interceptor->expectations_.pop();
         ++interceptor->hit_count_;
 
-        return new URLRequestMockJob(request,
-                                     network_delegate,
-                                     expectation.second);
+        return new URLRequestMockJob(request, network_delegate, response);
       }
     }
 
     return NULL;
   }
 
   typedef std::map<GURL, URLRequestPostInterceptor*> InterceptorMap;
   InterceptorMap interceptors_;
 
   const std::string scheme_;
@@ skipping 15 matching lines @@
 }
 
 URLRequestPostInterceptorFactory::~URLRequestPostInterceptorFactory() {
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&URLRequestPostInterceptor::Delegate::Unregister,
                  base::Unretained(delegate_)));
 }
 
 URLRequestPostInterceptor* URLRequestPostInterceptorFactory::CreateInterceptor(
-    const std::string& file_path) {
+    const base::FilePath& filepath) {
   const GURL base_url(base::StringPrintf("%s://%s",
                                          scheme_.c_str(),
                                          hostname_.c_str()));
-  GURL absolute_url(base_url.Resolve(file_path));
+  GURL absolute_url(base_url.Resolve(filepath.MaybeAsASCII()));
   URLRequestPostInterceptor* interceptor(
       new URLRequestPostInterceptor(absolute_url));
   bool res = BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&URLRequestPostInterceptor::Delegate::OnCreateInterceptor,
                  base::Unretained(delegate_),
                  base::Unretained(interceptor)));
   if (!res) {
     delete interceptor;
     return NULL;
   }
 
   return interceptor;
 }
 
 }  // namespace component_updater