Add PrerenderResourceHandler and hook it into the ResourceDispatcherHost....

chrome/browser/prerender/prerender_resource_handler_unittest.cc

Index: chrome/browser/prerender/prerender_resource_handler_unittest.cc
diff --git a/chrome/browser/prerender/prerender_resource_handler_unittest.cc b/chrome/browser/prerender/prerender_resource_handler_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..185dfd8966e1fcf8f7b50ac259d5b9b42259e016
--- /dev/null
+++ b/chrome/browser/prerender/prerender_resource_handler_unittest.cc
@@ -0,0 +1,226 @@
+// 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/prerender/prerender_resource_handler.h"
+#include "chrome/common/resource_response.h"
+#include "net/http/http_response_headers.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace {
+
+class MockResourceHandler : public ResourceHandler {
+ public:
+  MockResourceHandler() {}
+
+  virtual bool OnUploadProgress(int request_id,
+                                uint64 position,
+                                uint64 size) {
+    return true;
+  }
+
+  virtual bool OnRequestRedirected(int request_id, const GURL& url,
+                                   ResourceResponse* response,
+                                   bool* defer) {
+    *defer = false;
+    return true;
+  }
+
+  virtual bool OnResponseStarted(int request_id,
+                                 ResourceResponse* response) {
+    return true;
+  }
+
+  virtual bool OnWillStart(int request_id, const GURL& url, bool* defer) {
+    *defer = false;
+    return true;
+  }
+
+  virtual bool OnWillRead(int request_id,
+                          net::IOBuffer** buf,
+                          int* buf_size,
+                          int min_size) {
+    return true;
+  }
+
+  virtual bool OnReadCompleted(int request_id, int* bytes_read) {
+    return true;
+  }
+
+  virtual bool OnResponseCompleted(int request_id,
+                                   const URLRequestStatus& status,
+                                   const std::string& security_info) {
+    return true;
+  }
+
+  virtual void OnRequestClosed() {
+  }
+
+  virtual void OnDataDownloaded(int request_id, int bytes_downloaded) {}
+};
+
+class MockTimer : public PrerenderResourceHandler::Timer {
+ public:
+  MockTimer() : time_(base::Time::Now()) {}
+  virtual ~MockTimer() {}
+
+  virtual base::Time GetTime() const {
+    return time_;
+  }
+
+  void AdvanceTime(base::TimeDelta dt) {

[darin (slow to review), 2011/01/06 06:18:20]

I don't see any callers of AdvanceTime or set_time.

Have you considered just making PrerenderResourceHandler::Timer be a function
pointer?  It seems like you don't really need it to be an interface because you
don't really need to anything more than global "fake timer" state.

[cbentzel, 2011/01/06 15:29:49]

Moved to a function pointer. I initially had a test which used AdvanceTime [but
not set_time], but I realized that this was testing an unrealistic scenario and
was unnecessary.

+    time_ += dt;
+  }
+
+  void set_time(base::Time t) {
+    time_ = t;
+  }
+
+ private:
+  base::Time time_;
+};
+
+// HttpResponseHeaders expects the raw input for it's constructor
+// to be a NUL ('\0') separated string for each line. This is a little
+// difficult to do for string literals, so this helper function accepts
+// newline-separated string literals and does the substitution. The
+// returned object is expected to be deleted by the caller.
+net::HttpResponseHeaders* CreateResponseHeaders(
+    const char* newline_separated_headers) {
+  std::string headers(newline_separated_headers);
+  std::string::iterator i = headers.begin();
+  std::string::iterator end = headers.end();
+  while (i != end) {
+    if (*i == '\n')
+      *i = '\0';
+    ++i;
+  }
+  return new net::HttpResponseHeaders(headers);
+}
+
+}  // namespace
+
+class PrerenderResourceHandlerTest : public testing::Test {
+ protected:
+  PrerenderResourceHandlerTest()
+      : mock_timer_(new MockTimer()),
+        prerender_duration_(base::TimeDelta::FromSeconds(10)),
+        mock_handler_(new MockResourceHandler()),
+        ALLOW_THIS_IN_INITIALIZER_LIST(
+            pre_handler_(new PrerenderResourceHandler(
+                mock_handler_,
+                NewCallback(
+                    this,
+                    &PrerenderResourceHandlerTest::SetLastHandledURL)))),
+        ui_thread_(BrowserThread::UI, &loop_),
+        default_url_("http://www.prerender.com") {
+    // The handler owns the timer lifetime.
+    pre_handler_->set_timer(mock_timer_);
+    pre_handler_->set_prerender_duration(prerender_duration_);
+  }
+
+  void SetLastHandledURL(const GURL& url) {
+    last_handled_url_ = url;
+  }
+
+  // Common logic shared by many of the tests
+  void StartPrerendering(const std::string& mime_type,
+                         const char* headers) {
+    int request_id = 1;
+    bool defer = false;
+    EXPECT_TRUE(pre_handler_->OnWillStart(request_id, default_url_, &defer));
+    EXPECT_FALSE(defer);
+    scoped_refptr<ResourceResponse> response(new ResourceResponse);
+    response->response_head.request_time = mock_timer_->GetTime();
+    response->response_head.response_time = mock_timer_->GetTime();
+    response->response_head.mime_type = mime_type;
+    response->response_head.headers = CreateResponseHeaders(headers);
+    EXPECT_TRUE(last_handled_url_.is_empty());
+
+    // Start the response. If it is able to prerender, a task will
+    // be posted to loop_ (masquerading as the UI thread), and
+    // |SetLastHandledURL| will be called.
+    EXPECT_TRUE(pre_handler_->OnResponseStarted(request_id, response));
+    loop_.RunAllPending();
+  }
+
+  MockTimer* mock_timer_;
+  base::TimeDelta prerender_duration_;
+  scoped_refptr<MockResourceHandler> mock_handler_;
+  scoped_refptr<PrerenderResourceHandler> pre_handler_;
+  MessageLoop loop_;
+  BrowserThread ui_thread_;
+  GURL last_handled_url_;
+  GURL default_url_;
+};
+
+namespace {
+
+TEST_F(PrerenderResourceHandlerTest, NoOp) {
+}
+
+// Tests that a valid HTML resource will correctly get diverted
+// to the PrerenderManager.
+TEST_F(PrerenderResourceHandlerTest, Prerender) {
+  StartPrerendering("text/html",
+                    "HTTP/1.1 200 OK\n"
+                    "cache-control: max-age=86400\n");
+  EXPECT_EQ(default_url_, last_handled_url_);
+}
+
+// Tests that a no-cache HTML resource will not get diverted
+// to the PrerenderManager.
+TEST_F(PrerenderResourceHandlerTest, PrerenderNoCache) {
+  StartPrerendering("text/html",
+                    "HTTP/1.1 200 OK\n"
+                    "cache-control: no-cache\n");
+  EXPECT_TRUE(last_handled_url_.is_empty());
+}
+
+
+// Tests that a resource with the wrong MIME type (a GIF in this example)
+// will not be diverted to the PrerenderManager.
+TEST_F(PrerenderResourceHandlerTest, PrerenderWrongMimeType) {
+  StartPrerendering("image/gif",
+                    "HTTP/1.1 200 OK\n"
+                    "cache-control: max-age=86400\n");
+  EXPECT_TRUE(last_handled_url_.is_empty());
+}
+
+// Tests that a resource with a non-200 response will not be diverted
+// to the PrerenderManager
+TEST_F(PrerenderResourceHandlerTest, PrerenderBadResponseCode) {
+  StartPrerendering("text/html",
+                    "HTTP/1.1 403 Forbidden\n"
+                    "cache-control: max-age=86400\n");
+  EXPECT_TRUE(last_handled_url_.is_empty());
+}
+
+// Tests that the final request in a redirect chain will
+// get diverted to the PrerenderManager.
+TEST_F(PrerenderResourceHandlerTest, PrerenderRedirect) {
+  int request_id = 1;
+  GURL url_redirect("http://www.redirect.com");
+  bool defer = false;
+  EXPECT_TRUE(pre_handler_->OnWillStart(request_id, default_url_, &defer));
+  EXPECT_FALSE(defer);
+  EXPECT_TRUE(pre_handler_->OnRequestRedirected(request_id,
+                                                url_redirect,
+                                                NULL,
+                                                &defer));
+  EXPECT_FALSE(defer);
+  scoped_refptr<ResourceResponse> response(new ResourceResponse);
+  response->response_head.mime_type = "text/html";
+  response->response_head.request_time = mock_timer_->GetTime();
+  response->response_head.response_time = mock_timer_->GetTime();
+  response->response_head.headers = CreateResponseHeaders(
+      "HTTP/1.1 200 OK\n"
+      "cache-control: max-age=86400\n");
+  EXPECT_TRUE(pre_handler_->OnResponseStarted(request_id, response));
+  EXPECT_TRUE(last_handled_url_.is_empty());
+  loop_.RunAllPending();
+  EXPECT_EQ(url_redirect, last_handled_url_);
+}
+
+}
+