Change Interceptors into URLRequestJobFactory::ProtocolHandlers.

content/test/net/url_request_prepackaged_interceptor.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/net/url_request_prepackaged_interceptor.h"
+
+#include "base/file_util.h"
+#include "base/threading/thread_restrictions.h"
+#include "content/public/browser/browser_thread.h"
+#include "net/url_request/url_request.h"
+#include "net/url_request/url_request_filter.h"
+#include "net/url_request/url_request_test_job.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using content::BrowserThread;
+
+namespace content {
+
+class URLRequestPrepackagedInterceptor::Delegate
+    : public net::URLRequestJobFactory::ProtocolHandler {
+ public:
+  Delegate() : hit_count_(0) {}
+  virtual ~Delegate() {
+    net::URLRequestFilter::GetInstance()->RemoveHostnameHandler("http",
+                                                                "localhost");
+  }
+  void Register() {
+    net::URLRequestFilter::GetInstance()->AddHostnameProtocolHandler(
+        "http", "localhost", this);
+  }
+
+  // When requests for |url| arrive, respond with the contents of |path|. The
+  // hostname of |url| must be "localhost" to avoid DNS lookups, and the scheme
+  // must be "http".
+  void SetResponse(const std::string& url,
+                   const FilePath& path,
+                   bool ignore_query) {

[mmenke, 2012/12/11 17:22:38]

BrowserThread::CurrentlyOn(BrowserThread::IO)?

+    // It's ok to do a blocking disk access on this thread; this class
+    // is just used for tests.
+    base::ThreadRestrictions::ScopedAllowIO allow_io;
+    GURL gurl(url);
+    EXPECT_EQ("http", gurl.scheme());
+    EXPECT_EQ("localhost", gurl.host());
+    EXPECT_TRUE(file_util::PathExists(path));
+    if (ignore_query) {
+      ignore_query_responses_[gurl] = path;
+    } else {
+      responses_[gurl] = path;
+    }
+  }
+
+  // Returns how many requests have been issued that have a stored reply.
+  int GetHitCount() const {
+    base::AutoLock auto_lock(hit_count_lock_);
+    return hit_count_;
+  }
+
+ private:
+  // When computing matches, this ignores the query parameters of the url.
+  virtual net::URLRequestJob* MaybeCreateJob(
+      net::URLRequest* request,
+      net::NetworkDelegate* network_delegate) const OVERRIDE {
+    EXPECT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));

[mmenke, 2012/12/11 17:22:38]

May actually want to use CHECK here.  If we're on the wrong thread, things have
gone badly wrong in the test framework.

+    if (request->url().scheme() != "http" ||
+        request->url().host() != "localhost") {
+        return NULL;

[mmenke, 2012/12/11 17:22:38]

nit:  Fix indent.

+    }
+
+    // It's ok to do a blocking disk access on this thread; this class
+    // is just used for tests.
+    base::ThreadRestrictions::ScopedAllowIO allow_io;

[mmenke, 2012/12/11 17:22:38]

Suggest moving this to just before ReadFileToString, as that seems to be the
only place it's needed.

+
+    ResponseMap::const_iterator it = responses_.find(request->url());
+    if (it == responses_.end()) {
+      // Search for this request's url, ignoring any query parameters.
+      GURL url = request->url();
+      if (url.has_query()) {
+        GURL::Replacements replacements;
+        replacements.ClearQuery();
+        url = url.ReplaceComponents(replacements);
+      }
+      it = ignore_query_responses_.find(url);
+      if (it == ignore_query_responses_.end())
+        return NULL;
+    }
+    const FilePath& response = it->second;
+    {
+      base::AutoLock auto_lock(hit_count_lock_);
+      ++hit_count_;
+    }
+
+    std::string contents;
+    EXPECT_TRUE(file_util::ReadFileToString(response, &contents));

[mmenke, 2012/12/11 17:22:38]

Can we just use a "URLRequestMockHTTPJob" here?

[pauljensen, 2012/12/17 16:26:49]

I tried for a while to use URLRequestMockHTTPJob but this required adding lots
of *.mock-http-headers files as the update logic requires HTTP 200 response
codes.  I was fine with adding these files until it came to a new test that was
just added that creates files in a uniquely named temporary directory. 
Programmatically creating the .mock-http-headers for that test just seemed like
too much circumvention logic.  So I did what AutoUpdateInterceptor used to do,
and just made a tiny URLRequestJob class that inherited from URLRequestFileJob
and added the 200 response code.  This way the file I/O is done nicely on the
appropriate thread and we don't need the second ScopedAllowIO.

[mmenke, 2012/12/18 20:32:15]

Could just fix URLRequestMockHTTPJob to use a nice set of default headers.

[mmenke, 2012/12/19 16:21:21]

BTW - no need to worry about that now.  Your solution is fine.  (Thought I
removed the comment).

+
+    return new net::URLRequestTestJob(request,
+                                      network_delegate,
+                                      net::URLRequestTestJob::test_headers(),
+                                      contents,
+                                      true);
+  }
+
+  typedef std::map<GURL, FilePath> ResponseMap;
+  ResponseMap responses_;
+  ResponseMap ignore_query_responses_;
+
+  mutable base::Lock hit_count_lock_;
+  mutable int hit_count_;
+
+  DISALLOW_COPY_AND_ASSIGN(Delegate);
+};
+
+
+URLRequestPrepackagedInterceptor::URLRequestPrepackagedInterceptor()
+    : delegate_(new Delegate) {
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                          base::Bind(&Delegate::Register,
+                                     base::Unretained(delegate_)));
+}
+
+URLRequestPrepackagedInterceptor::~URLRequestPrepackagedInterceptor() {
+  BrowserThread::DeleteSoon(BrowserThread::IO, FROM_HERE, delegate_);
+}
+
+void URLRequestPrepackagedInterceptor::SetResponse(const std::string& url,
+                                                   const FilePath& path) {

[mmenke, 2012/12/11 17:22:38]

Suggest a DCHECK_EQ on url.hostname

+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                          base::Bind(&Delegate::SetResponse,
+                                     base::Unretained(delegate_), url, path,
+                                     false));
+}
+
+void URLRequestPrepackagedInterceptor::SetResponseIgnoreQuery(
+    const std::string& url,
+    const FilePath& path) {
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                          base::Bind(&Delegate::SetResponse,
+                                     base::Unretained(delegate_), url, path,
+                                     true));
+}
+
+int URLRequestPrepackagedInterceptor::GetHitCount() {
+  return delegate_->GetHitCount();
+}
+
+}  // namespace content