predictors: Add tests to ResourcePrefetchPredictor.

chrome/browser/predictors/resource_prefetch_predictor_unittest.cc

 // Copyright 2014 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/predictors/resource_prefetch_predictor.h"
 
 #include <iostream>
 #include <memory>
 
+#include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/time/time.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/predictors/resource_prefetch_predictor_tables.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/history/core/browser/history_service.h"
 #include "components/history/core/browser/history_types.h"
+#include "content/public/browser/resource_request_info.h"
 #include "content/public/test/test_browser_thread.h"
+#include "net/http/http_response_headers.h"
+#include "net/url_request/url_request_context.h"
+#include "net/url_request/url_request_job.h"
+#include "net/url_request/url_request_test_util.h"
+#include "net/url_request/url_request_test_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::ContainerEq;
 using testing::Pointee;
 using testing::SetArgPointee;
 using testing::StrictMock;
 
 namespace predictors {
 
@@ skipping 15 matching lines @@
   *os << "[" << data.key_type << "," << data.primary_key
       << "," << data.last_visit.ToInternalValue() << "]\n";
   for (ResourceRows::const_iterator it = data.resources.begin();
        it != data.resources.end(); ++it) {
     *os << "\t\t";
     PrintTo(*it, os);
     *os << "\n";
   }
 }
 
+class MockURLRequestDelegate : public net::URLRequest::Delegate {

[pasko, 2016/08/10 16:40:07]

it is not a powerful mock, would be more readable to call it something like
NoopURLRequestDelegate or EmptyURLRequestDelegate.

[Benoit L, 2016/08/17 12:32:19]

Done.

+  void OnResponseStarted(net::URLRequest* request) override {}
+  void OnReadCompleted(net::URLRequest* request, int bytes_read) override {}
+};
+
+class MockURLRequestJob : public net::URLRequestJob {
+ public:
+  MockURLRequestJob(net::URLRequest* request,
+                    const net::HttpResponseInfo& response_info,
+                    const std::string& mime_type)
+      : net::URLRequestJob(request, nullptr),
+        response_info_(response_info),
+        mime_type_(mime_type) {}
+
+  bool GetMimeType(std::string* mime_type) const override {
+    *mime_type = mime_type_;
+    return true;
+  }
+
+ protected:
+  void Start() override { NotifyHeadersComplete(); }
+  int GetResponseCode() const override { return 200; }
+  void GetResponseInfo(net::HttpResponseInfo* info) override {
+    *info = response_info_;
+  }
+
+ private:
+  net::HttpResponseInfo response_info_;
+  std::string mime_type_;
+};
+
+class MockURLRequestJobFactory : public net::URLRequestJobFactory {
+ public:
+  MockURLRequestJobFactory() {}
+  ~MockURLRequestJobFactory() override {}
+
+  net::URLRequestJob* MaybeCreateJobWithProtocolHandler(
+      const std::string& scheme,
+      net::URLRequest* request,
+      net::NetworkDelegate* network_delegate) const override {
+    return new MockURLRequestJob(request, response_info, mime_type);
+  }
+
+  net::URLRequestJob* MaybeInterceptRedirect(
+      net::URLRequest* request,
+      net::NetworkDelegate* network_delegate,
+      const GURL& location) const override {
+    return nullptr;
+  }
+
+  net::URLRequestJob* MaybeInterceptResponse(
+      net::URLRequest* request,
+      net::NetworkDelegate* network_delegate) const override {
+    return nullptr;
+  }
+
+  bool IsHandledProtocol(const std::string& scheme) const override {
+    return true;
+  }
+
+  bool IsHandledURL(const GURL& url) const override { return true; }
+
+  bool IsSafeRedirectTarget(const GURL& location) const override {
+    return true;
+  }
+
+  net::HttpResponseInfo response_info;

[pasko, 2016/08/10 16:40:06]

public members in classes are discouraged, sorry. This class is not struct-level
trivial.

In particular, it is making it less easy to read the MaybeCreateJob[...],
totally not obvious where 'mime_type' is coming from.

[Benoit L, 2016/08/17 12:32:19]

Done.

+  std::string mime_type;
+};
+
 class MockResourcePrefetchPredictorTables
     : public ResourcePrefetchPredictorTables {
  public:
   MockResourcePrefetchPredictorTables() { }
 
   MOCK_METHOD2(GetAllData, void(PrefetchDataMap* url_data_map,
                                 PrefetchDataMap* host_data_map));
   MOCK_METHOD2(UpdateData, void(const PrefetchData& url_data,
                                 const PrefetchData& host_data));
   MOCK_METHOD2(DeleteData, void(const std::vector<std::string>& urls,
@@ skipping 52 matching lines @@
     summary.navigation_id = CreateNavigationID(process_id, render_frame_id,
                                                main_frame_url);
     summary.resource_url = GURL(resource_url);
     summary.resource_type = resource_type;
     summary.priority = priority;
     summary.mime_type = mime_type;
     summary.was_cached = was_cached;
     return summary;
   }
 
+  std::unique_ptr<net::URLRequest> CreateURLRequest(
+      const GURL& url,
+      net::RequestPriority priority,
+      content::ResourceType resource_type,
+      int render_process_id,
+      int render_frame_id,
+      bool is_main_frame) {
+    auto request = url_request_context_.CreateRequest(url, priority,

[pasko, 2016/08/10 16:40:07]

TIL: we discourage auto-ing smart pointers, see discussion:

https://groups.google.com/a/chromium.org/forum/#!topic/chromium-dev/5-Bt3BJzAo0

[Benoit L, 2016/08/17 12:32:19]

Done.

+                                                      &url_request_delegate_);
+    request->set_first_party_for_cookies(url);
+    content::ResourceRequestInfo::AllocateForTesting(
+        request.get(), resource_type, nullptr, render_process_id, -1,
+        render_frame_id, is_main_frame, false, false, true, false);
+    request->Start();
+    return request;
+  }
+
   void InitializePredictor() {
     predictor_->StartInitialization();
     base::RunLoop loop;
     loop.RunUntilIdle();  // Runs the DB lookup.
     profile_->BlockUntilHistoryProcessesPendingRequests();
   }
 
   bool URLRequestSummaryAreEqual(const URLRequestSummary& lhs,
                                  const URLRequestSummary& rhs) {
     return lhs.navigation_id == rhs.navigation_id &&
@@ skipping 17 matching lines @@
     predictor_.reset(new ResourcePrefetchPredictor(config, profile_.get()));
     predictor_->set_mock_tables(mock_tables_);
   }
 
   void InitializeSampleData();
 
   base::MessageLoop loop_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread db_thread_;
   std::unique_ptr<TestingProfile> profile_;
+  net::TestURLRequestContext url_request_context_;
 
   std::unique_ptr<ResourcePrefetchPredictor> predictor_;
   scoped_refptr<StrictMock<MockResourcePrefetchPredictorTables> > mock_tables_;
 
   PrefetchDataMap test_url_data_;
   PrefetchDataMap test_host_data_;
   PrefetchData empty_url_data_;
   PrefetchData empty_host_data_;
+
+  MockURLRequestJobFactory url_request_job_factory_;
+  MockURLRequestDelegate url_request_delegate_;
 };
 
 ResourcePrefetchPredictorTest::ResourcePrefetchPredictorTest()
     : loop_(base::MessageLoop::TYPE_DEFAULT),
       ui_thread_(content::BrowserThread::UI, &loop_),
       db_thread_(content::BrowserThread::DB, &loop_),
       profile_(new TestingProfile()),
       mock_tables_(new StrictMock<MockResourcePrefetchPredictorTables>()),
       empty_url_data_(PREFETCH_KEY_TYPE_URL, std::string()),
       empty_host_data_(PREFETCH_KEY_TYPE_HOST, std::string()) {}
@@ skipping 14 matching lines @@
   ResetPredictor();
   EXPECT_EQ(predictor_->initialization_state_,
             ResourcePrefetchPredictor::NOT_INITIALIZED);
   EXPECT_CALL(*mock_tables_.get(),
               GetAllData(Pointee(ContainerEq(PrefetchDataMap())),
                          Pointee(ContainerEq(PrefetchDataMap()))));
   InitializePredictor();
   EXPECT_TRUE(predictor_->inflight_navigations_.empty());
   EXPECT_EQ(predictor_->initialization_state_,
             ResourcePrefetchPredictor::INITIALIZED);
+
+  url_request_context_.set_job_factory(&url_request_job_factory_);
 }
 
 void ResourcePrefetchPredictorTest::TearDown() {
   predictor_.reset(NULL);
   profile_->DestroyHistoryService();
 }
 
 void ResourcePrefetchPredictorTest::InitializeSampleData() {
   {  // Url data.
     PrefetchData google(PREFETCH_KEY_TYPE_URL, "http://www.google.com/");
@@ skipping 560 matching lines @@
   EXPECT_FALSE(ResourcePrefetchPredictor::IsHandledResourceType(
       content::RESOURCE_TYPE_PREFETCH, "bogus/mime-type"));
   EXPECT_FALSE(ResourcePrefetchPredictor::IsHandledResourceType(
       content::RESOURCE_TYPE_PREFETCH, ""));
   EXPECT_TRUE(ResourcePrefetchPredictor::IsHandledResourceType(
       content::RESOURCE_TYPE_PREFETCH, "application/font-woff"));
   EXPECT_TRUE(ResourcePrefetchPredictor::IsHandledResourceType(
       content::RESOURCE_TYPE_PREFETCH, "font/woff2"));
 }
 
+TEST_F(ResourcePrefetchPredictorTest, ShouldRecordRequestMainFrame) {
+  std::unique_ptr<net::URLRequest> http_request =
+      CreateURLRequest(GURL("http://www.google.com"), net::MEDIUM,
+                       content::RESOURCE_TYPE_IMAGE, 1, 1, true);
+  EXPECT_TRUE(ResourcePrefetchPredictor::ShouldRecordRequest(
+      http_request.get(), content::RESOURCE_TYPE_MAIN_FRAME));
+
+  std::unique_ptr<net::URLRequest> https_request =
+      CreateURLRequest(GURL("https://www.google.com"), net::MEDIUM,
+                       content::RESOURCE_TYPE_IMAGE, 1, 1, true);
+  EXPECT_TRUE(ResourcePrefetchPredictor::ShouldRecordRequest(
+      https_request.get(), content::RESOURCE_TYPE_MAIN_FRAME));
+
+  std::unique_ptr<net::URLRequest> file_request =
+      CreateURLRequest(GURL("file://www.google.com"), net::MEDIUM,
+                       content::RESOURCE_TYPE_IMAGE, 1, 1, true);
+  EXPECT_FALSE(ResourcePrefetchPredictor::ShouldRecordRequest(
+      file_request.get(), content::RESOURCE_TYPE_MAIN_FRAME));
+}
+
+TEST_F(ResourcePrefetchPredictorTest, ShouldRecordRequestSubResource) {
+  std::unique_ptr<net::URLRequest> http_request =
+      CreateURLRequest(GURL("http://www.google.com/cat.png"), net::MEDIUM,
+                       content::RESOURCE_TYPE_IMAGE, 1, 1, false);
+  EXPECT_FALSE(ResourcePrefetchPredictor::ShouldRecordRequest(
+      http_request.get(), content::RESOURCE_TYPE_IMAGE));
+
+  std::unique_ptr<net::URLRequest> https_request =
+      CreateURLRequest(GURL("https://www.google.com/cat.png"), net::MEDIUM,
+                       content::RESOURCE_TYPE_IMAGE, 1, 1, false);
+  EXPECT_FALSE(ResourcePrefetchPredictor::ShouldRecordRequest(
+      https_request.get(), content::RESOURCE_TYPE_IMAGE));
+
+  std::unique_ptr<net::URLRequest> file_request =
+      CreateURLRequest(GURL("file://www.google.com/cat.png"), net::MEDIUM,
+                       content::RESOURCE_TYPE_IMAGE, 1, 1, false);
+  EXPECT_FALSE(ResourcePrefetchPredictor::ShouldRecordRequest(
+      file_request.get(), content::RESOURCE_TYPE_IMAGE));
+}
+
+TEST_F(ResourcePrefetchPredictorTest, ShouldRecordResponseMainFrame) {
+  url_request_job_factory_.response_info.headers =
+      scoped_refptr<net::HttpResponseHeaders>(new net::HttpResponseHeaders(""));
+
+  std::unique_ptr<net::URLRequest> http_request =
+      CreateURLRequest(GURL("http://www.google.com"), net::MEDIUM,
+                       content::RESOURCE_TYPE_MAIN_FRAME, 1, 1, true);
+  EXPECT_TRUE(
+      ResourcePrefetchPredictor::ShouldRecordResponse(http_request.get()));
+
+  std::unique_ptr<net::URLRequest> https_request =
+      CreateURLRequest(GURL("https://www.google.com"), net::MEDIUM,
+                       content::RESOURCE_TYPE_MAIN_FRAME, 1, 1, true);
+  EXPECT_TRUE(
+      ResourcePrefetchPredictor::ShouldRecordResponse(https_request.get()));
+
+  std::unique_ptr<net::URLRequest> file_request =
+      CreateURLRequest(GURL("file://www.google.com"), net::MEDIUM,
+                       content::RESOURCE_TYPE_MAIN_FRAME, 1, 1, true);
+  EXPECT_FALSE(
+      ResourcePrefetchPredictor::ShouldRecordResponse(file_request.get()));
+}
+
+TEST_F(ResourcePrefetchPredictorTest, ShouldRecordResponseSubresource) {
+  url_request_job_factory_.response_info.headers =
+      scoped_refptr<net::HttpResponseHeaders>(
+          new net::HttpResponseHeaders("HTTP/1.1 200 OK\n\nSome: Headers\n"));
+  url_request_job_factory_.response_info.was_cached = true;
+
+  // Protocol
+  std::unique_ptr<net::URLRequest> http_image_request =
+      CreateURLRequest(GURL("http://www.google.com/cat.png"), net::MEDIUM,
+                       content::RESOURCE_TYPE_IMAGE, 1, 1, true);
+  EXPECT_TRUE(ResourcePrefetchPredictor::ShouldRecordResponse(
+      http_image_request.get()));
+
+  std::unique_ptr<net::URLRequest> https_image_request =
+      CreateURLRequest(GURL("https://www.google.com/cat.png"), net::MEDIUM,
+                       content::RESOURCE_TYPE_IMAGE, 1, 1, true);
+  EXPECT_TRUE(ResourcePrefetchPredictor::ShouldRecordResponse(
+      https_image_request.get()));
+
+  std::unique_ptr<net::URLRequest> file_image_request =
+      CreateURLRequest(GURL("file://www.google.com/cat.png"), net::MEDIUM,
+                       content::RESOURCE_TYPE_IMAGE, 1, 1, true);
+  EXPECT_FALSE(ResourcePrefetchPredictor::ShouldRecordResponse(
+      file_image_request.get()));
+
+  // ResourceType
+  std::unique_ptr<net::URLRequest> sub_frame_request =
+      CreateURLRequest(GURL("http://www.google.com/frame.html"), net::MEDIUM,
+                       content::RESOURCE_TYPE_SUB_FRAME, 1, 1, true);
+  EXPECT_FALSE(
+      ResourcePrefetchPredictor::ShouldRecordResponse(sub_frame_request.get()));
+
+  std::unique_ptr<net::URLRequest> font_request = CreateURLRequest(
+      GURL("http://www.google.com/comic-sans-ms.woff"), net::MEDIUM,
+      content::RESOURCE_TYPE_FONT_RESOURCE, 1, 1, true);
+  EXPECT_TRUE(
+      ResourcePrefetchPredictor::ShouldRecordResponse(font_request.get()));
+
+  // From MIME Type.
+  url_request_job_factory_.mime_type = "image/png";
+  std::unique_ptr<net::URLRequest> prefetch_image_request =
+      CreateURLRequest(GURL("http://www.google.com/cat.png"), net::MEDIUM,
+                       content::RESOURCE_TYPE_PREFETCH, 1, 1, true);
+  EXPECT_TRUE(ResourcePrefetchPredictor::ShouldRecordResponse(
+      prefetch_image_request.get()));
+
+  url_request_job_factory_.mime_type = "image/my-wonderful-format";
+  std::unique_ptr<net::URLRequest> prefetch_unknown_image_request =
+      CreateURLRequest(GURL("http://www.google.com/cat.png"), net::MEDIUM,
+                       content::RESOURCE_TYPE_PREFETCH, 1, 1, true);
+  EXPECT_FALSE(ResourcePrefetchPredictor::ShouldRecordResponse(
+      prefetch_unknown_image_request.get()));
+
+  url_request_job_factory_.mime_type = "font/woff";
+  std::unique_ptr<net::URLRequest> prefetch_font_request = CreateURLRequest(
+      GURL("http://www.google.com/comic-sans-ms.woff"), net::MEDIUM,
+      content::RESOURCE_TYPE_PREFETCH, 1, 1, true);
+  EXPECT_TRUE(ResourcePrefetchPredictor::ShouldRecordResponse(
+      prefetch_font_request.get()));
+
+  url_request_job_factory_.mime_type = "font/woff-woff";
+  std::unique_ptr<net::URLRequest> prefetch_unknown_font_request =
+      CreateURLRequest(GURL("http://www.google.com/comic-sans-ms.woff"),
+                       net::MEDIUM, content::RESOURCE_TYPE_PREFETCH, 1, 1,
+                       true);
+  EXPECT_FALSE(ResourcePrefetchPredictor::ShouldRecordResponse(
+      prefetch_unknown_font_request.get()));
+
+  // Not main frame
+  std::unique_ptr<net::URLRequest> font_request_sub_frame = CreateURLRequest(
+      GURL("http://www.google.com/comic-sans-ms.woff"), net::MEDIUM,
+      content::RESOURCE_TYPE_FONT_RESOURCE, 1, 1, false);
+  EXPECT_FALSE(ResourcePrefetchPredictor::ShouldRecordResponse(
+      font_request_sub_frame.get()));
+}
+
 }  // namespace predictors