predictors: Basic browsertest checks predictor learning.

chrome/browser/predictors/resource_prefetch_predictor_browsertest.cc

+// Copyright 2016 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 "base/command_line.h"
+#include "chrome/browser/predictors/resource_prefetch_predictor.h"
+#include "chrome/browser/predictors/resource_prefetch_predictor_factory.h"
+#include "chrome/browser/predictors/resource_prefetch_predictor_test_util.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/ui/browser.h"
+#include "chrome/browser/ui/tabs/tab_strip_model.h"
+#include "chrome/common/chrome_switches.h"
+#include "chrome/test/base/in_process_browser_test.h"
+#include "chrome/test/base/ui_test_utils.h"
+#include "content/public/browser/render_frame_host.h"
+#include "content/public/browser/render_process_host.h"
+#include "net/test/embedded_test_server/http_request.h"
+#include "net/test/embedded_test_server/http_response.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using testing::UnorderedElementsAreArray;
+
+namespace predictors {
+
+using PageRequestSummary = ResourcePrefetchPredictor::PageRequestSummary;
+using URLRequestSummary = ResourcePrefetchPredictor::URLRequestSummary;
+using net::test_server::HttpRequest;
+using net::test_server::HttpResponse;
+using net::test_server::BasicHttpResponse;
+
+struct ResourceSummary {
+  ResourceSummary() : is_no_store(false), version(0) {}
+
+  URLRequestSummary request;
+  std::string content;
+  bool is_no_store;
+  size_t version;
+};
+
+// Corresponds to blink::typeToPrioriity function.

[Benoit L, 2016/11/02 17:35:47]

typo: typeToPriority.

[alexilin, 2016/11/02 17:49:17]

Done.

+net::RequestPriority GetDefaultPriorityForType(content::ResourceType type) {

[Benoit L, 2016/11/02 17:35:47]

Per offline discussion, I think it's simpler to hardcode the priority as was
done in the previous patch.

Sorry for the misunderstanding.

[alexilin, 2016/11/02 17:49:17]

Never mind.
Done.

+  switch (type) {
+    case content::RESOURCE_TYPE_STYLESHEET:
+    case content::RESOURCE_TYPE_FONT_RESOURCE:
+      return net::HIGHEST;
+    case content::RESOURCE_TYPE_SCRIPT:
+      return net::MEDIUM;
+    case content::RESOURCE_TYPE_IMAGE:
+      return net::LOWEST;
+    default:
+      return net::DEFAULT_PRIORITY;
+  }
+}
+
+std::string GetDefaultMimeTypeForType(content::ResourceType type) {
+  switch (type) {
+    case content::RESOURCE_TYPE_STYLESHEET:
+      return "text/css";
+    case content::RESOURCE_TYPE_FONT_RESOURCE:
+      return "application/x-font-truetype";
+    case content::RESOURCE_TYPE_SCRIPT:
+      return "application/javascript";
+    case content::RESOURCE_TYPE_IMAGE:
+      return "image/png";
+    default:
+      return "application/octet-stream";
+  }
+}
+
+std::string GetDefaultResourceUrlForType(content::ResourceType type) {
+  switch (type) {
+    case content::RESOURCE_TYPE_STYLESHEET:
+      return "/predictors/style.css";
+    case content::RESOURCE_TYPE_FONT_RESOURCE:
+      return "/predictors/font.ttf";
+    case content::RESOURCE_TYPE_SCRIPT:
+      return "/predictors/script.js";
+    case content::RESOURCE_TYPE_IMAGE:
+      return "/predictors/image.png";
+    default:
+      return "/predictors/resource";
+  }
+}
+
+// Helper class to track and allow waiting for ResourcePrefetchPredictor events.
+class ResourcePrefetchPredictorTestObserver : public TestObserver {
+ public:
+  explicit ResourcePrefetchPredictorTestObserver(
+      ResourcePrefetchPredictor* predictor,
+      const size_t expected_url_visit_count,
+      const PageRequestSummary& expected_summary)
+      : TestObserver(predictor),
+        message_loop_runner_(new content::MessageLoopRunner()),
+        url_visit_count_(expected_url_visit_count),
+        summary_(expected_summary) {}
+
+  ~ResourcePrefetchPredictorTestObserver() override {}
+
+  // ResourcePrefetchPredictor::Observer
+  void OnNavigationLearned(size_t url_visit_count,
+                           const PageRequestSummary& summary) override {
+    EXPECT_EQ(url_visit_count, url_visit_count_);
+    EXPECT_EQ(summary.main_frame_url, summary_.main_frame_url);
+    EXPECT_EQ(summary.initial_url, summary_.initial_url);
+    EXPECT_THAT(summary.subresource_requests,
+                UnorderedElementsAreArray(summary_.subresource_requests));
+    message_loop_runner_->Quit();
+  }
+
+  void Wait() { message_loop_runner_->Run(); }
+
+ private:
+  scoped_refptr<content::MessageLoopRunner> message_loop_runner_;
+  size_t url_visit_count_;
+  PageRequestSummary summary_;
+
+  DISALLOW_COPY_AND_ASSIGN(ResourcePrefetchPredictorTestObserver);
+};
+
+class ResourcePrefetchPredictorBrowserTest : public InProcessBrowserTest {
+ public:
+  void SetUpCommandLine(base::CommandLine* command_line) override {
+    command_line->AppendSwitchASCII(
+        switches::kSpeculativeResourcePrefetching,
+        switches::kSpeculativeResourcePrefetchingEnabled);
+  }
+
+  void SetUpOnMainThread() override {
+    embedded_test_server()->RegisterRequestHandler(
+        base::Bind(&ResourcePrefetchPredictorBrowserTest::HandleRequest,
+                   base::Unretained(this)));
+    ASSERT_TRUE(embedded_test_server()->Start());
+    predictor_ =
+        ResourcePrefetchPredictorFactory::GetForProfile(browser()->profile());
+    ASSERT_TRUE(predictor_);
+  }
+
+  void NavigateToURLAndCheckSubresources(
+      const std::string& main_frame_relative) {
+    GURL main_frame_absolute =
+        embedded_test_server()->GetURL(main_frame_relative);
+    std::vector<URLRequestSummary> url_request_summaries;
+    for (const auto& kv : resources_) {
+      if (kv.second.is_no_store)
+        continue;
+      url_request_summaries.push_back(
+          GetURLRequestSummaryForResource(main_frame_absolute, kv.second));
+    }
+    ResourcePrefetchPredictorTestObserver observer(
+        predictor_, UpdateAndGetVisitCount(main_frame_relative),
+        CreatePageRequestSummary(main_frame_absolute.spec(),
+                                 main_frame_absolute.spec(),
+                                 url_request_summaries));
+    ui_test_utils::NavigateToURL(browser(), main_frame_absolute);
+    observer.Wait();
+  }
+
+  void AddDefaultResourceByType(content::ResourceType resource_type) {
+    AddResource(GetDefaultResourceUrlForType(resource_type), resource_type,
+                GetDefaultPriorityForType(resource_type),
+                GetDefaultMimeTypeForType(resource_type));
+  }
+
+  void AddResource(const std::string& relative_url,
+                   content::ResourceType resource_type,
+                   net::RequestPriority priority,
+                   const std::string& mime_type,
+                   bool has_validators = true,
+                   bool always_revalidate = false,
+                   const std::string& content = std::string(),
+                   bool is_no_store = false) {
+    ResourceSummary resource;
+    GURL resource_url = embedded_test_server()->GetURL(relative_url);
+    resource.request = CreateURLRequestSummary(
+        -1, -1, std::string(), resource_url.spec(), resource_type, priority,
+        mime_type, false, std::string(), has_validators, always_revalidate);
+    resource.content = content;
+    resource.is_no_store = is_no_store;
+    resources_[relative_url] = resource;
+  }
+
+ private:
+  URLRequestSummary GetURLRequestSummaryForResource(
+      const GURL& main_frame_url,
+      const ResourceSummary& resource_summary) {
+    URLRequestSummary summary(resource_summary.request);
+    content::WebContents* web_contents =
+        browser()->tab_strip_model()->GetActiveWebContents();
+    int process_id = web_contents->GetRenderProcessHost()->GetID();
+    int frame_id = web_contents->GetMainFrame()->GetRoutingID();
+    summary.navigation_id =
+        CreateNavigationID(process_id, frame_id, main_frame_url.spec());
+    return summary;
+  }
+
+  std::unique_ptr<HttpResponse> HandleRequest(const HttpRequest& request) {
+    auto resource_it = resources_.find(request.relative_url);
+    if (resource_it == resources_.end())
+      return nullptr;
+
+    const ResourceSummary& summary = resource_it->second;
+    std::unique_ptr<BasicHttpResponse> http_response =
+        base::MakeUnique<BasicHttpResponse>();
+    http_response->set_code(net::HTTP_OK);
+    http_response->set_content_type(summary.request.mime_type);
+    http_response->set_content(summary.content);
+    if (summary.is_no_store)
+      http_response->AddCustomHeader("Cache-Control", "no-store");
+    if (summary.request.has_validators) {
+      http_response->AddCustomHeader(
+          "ETag", base::StringPrintf("'%zu%s'", summary.version,
+                                     request.relative_url.c_str()));
+    }
+    if (summary.request.always_revalidate)
+      http_response->AddCustomHeader("Cache-Control", "no-cache");
+    else
+      http_response->AddCustomHeader("Cache-Control", "max-age=2147483648");
+    return std::move(http_response);
+  }
+
+  size_t UpdateAndGetVisitCount(const std::string& main_frame_relative) {
+    return ++visit_count_[main_frame_relative];
+  }
+
+  ResourcePrefetchPredictor* predictor_;
+  std::map<std::string, ResourceSummary> resources_;
+  std::map<std::string, size_t> visit_count_;
+};
+
+IN_PROC_BROWSER_TEST_F(ResourcePrefetchPredictorBrowserTest, ) {
+  AddDefaultResourceByType(content::RESOURCE_TYPE_IMAGE);
+  AddDefaultResourceByType(content::RESOURCE_TYPE_STYLESHEET);
+  AddDefaultResourceByType(content::RESOURCE_TYPE_SCRIPT);
+  AddDefaultResourceByType(content::RESOURCE_TYPE_FONT_RESOURCE);
+  NavigateToURLAndCheckSubresources("/predictors/html_subresources.html");
+}
+
+}  // namespace predictors