predictors: Introduce GlowplugPredictor.

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 <stddef.h>
 
 #include <algorithm>
 #include <set>
 
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_util.h"
 #include "base/test/histogram_tester.h"
 #include "chrome/browser/browsing_data/browsing_data_helper.h"
 
-#include "chrome/browser/browsing_data/chrome_browsing_data_remover_delegate.h"
-#include "chrome/browser/predictors/resource_prefetch_predictor.h"
-#include "chrome/browser/predictors/resource_prefetch_predictor_factory.h"
+#include "chrome/browser/predictors/loading_predictor.h"
+#include "chrome/browser/predictors/loading_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/browsing_data_remover.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/url_util.h"
@@ skipping 329 matching lines @@
           base::Unretained(this)));
       server->RegisterRequestHandler(base::Bind(
           &ResourcePrefetchPredictorBrowserTest::HandleResourceRequest,
           base::Unretained(this)));
       server->RegisterRequestMonitor(base::Bind(
           &ResourcePrefetchPredictorBrowserTest::MonitorResourceRequest,
           base::Unretained(this)));
       ASSERT_TRUE(server->Start());
     }
 
-    predictor_ =
-        ResourcePrefetchPredictorFactory::GetForProfile(browser()->profile());
+    predictor_ = LoadingPredictorFactory::GetForProfile(browser()->profile());
     ASSERT_TRUE(predictor_);
+    resource_prefetch_predictor_ = predictor_->resource_prefetch_predictor();
     // URLs from the test server contain a port number.
     ResourcePrefetchPredictor::SetAllowPortInUrlsForTesting(true);
     EnsurePredictorInitialized();
     histogram_tester_.reset(new base::HistogramTester());
   }
 
   void TearDownOnMainThread() override {
     ResourcePrefetchPredictor::SetAllowPortInUrlsForTesting(false);
   }
 
@@ skipping 41 matching lines @@
       if (kv.second.is_observable) {
         url_request_summaries.push_back(
             GetURLRequestSummaryForResource(main_frame_url, kv.second));
       }
     }
 
     bool match_navigation_id =
         disposition == WindowOpenDisposition::CURRENT_TAB;
 
     LearningObserver observer(
-        predictor_, UpdateAndGetVisitCount(initial_url),
+        resource_prefetch_predictor_, UpdateAndGetVisitCount(initial_url),
         CreatePageRequestSummary(main_frame_url.spec(), initial_url.spec(),
                                  url_request_summaries),
         match_navigation_id, match_before_first_contentful_paint);
     ui_test_utils::NavigateToURLWithDisposition(
         browser(), navigation_url, disposition,
         ui_test_utils::BROWSER_TEST_NONE);
     observer.Wait();
 
     for (auto& kv : resources_) {
       if (kv.second.is_observable)
         kv.second.request.was_cached = true;
     }
     for (const auto& nav : observer.current_navigation_ids())
       navigation_id_history_.insert(nav);
   }
 
   void NavigateToURLAndCheckPrefetching(const GURL& main_frame_url) {
-    PrefetchingObserver observer(predictor_, main_frame_url, true);
+    PrefetchingObserver observer(resource_prefetch_predictor_, main_frame_url,
+                                 true);
     ui_test_utils::NavigateToURL(browser(), main_frame_url);
     observer.Wait();
     for (auto& kv : resources_) {
       if (kv.second.is_observable)
         kv.second.request.was_cached = true;
     }
   }
 
   void PrefetchURL(const GURL& main_frame_url) {
-    PrefetchingObserver observer(predictor_, main_frame_url, false);
-    predictor_->StartPrefetching(main_frame_url, PrefetchOrigin::EXTERNAL);
+    PrefetchingObserver observer(resource_prefetch_predictor_, main_frame_url,
+                                 false);
+    predictor_->PrepareForPageLoad(main_frame_url, HintOrigin::EXTERNAL);
     observer.Wait();
     for (auto& kv : resources_) {
       if (kv.second.is_observable)
         kv.second.request.was_cached = true;
     }
   }
 
   void TryToPrefetchURL(const GURL& main_frame_url) {
-    predictor_->StartPrefetching(main_frame_url, PrefetchOrigin::EXTERNAL);
+    predictor_->PrepareForPageLoad(main_frame_url, HintOrigin::EXTERNAL);
   }
 
   ResourceSummary* AddResource(const GURL& resource_url,
                                content::ResourceType resource_type,
                                net::RequestPriority priority) {
     auto pair_and_whether_inserted =
         resources_.insert(std::make_pair(resource_url, ResourceSummary()));
     EXPECT_TRUE(pair_and_whether_inserted.second) << resource_url
                                                   << " was inserted twice";
     ResourceSummary* resource = &pair_and_whether_inserted.first->second;
@@ skipping 100 matching lines @@
             AddResource(GetURLWithHost(kFont[0], kFont[1]),
                         content::RESOURCE_TYPE_FONT_RESOURCE, net::HIGHEST)};
   }
 
   std::unique_ptr<base::HistogramTester> histogram_tester_;
 
  private:
   // ResourcePrefetchPredictor needs to be initialized before the navigation
   // happens otherwise this navigation will be ignored by predictor.
   void EnsurePredictorInitialized() {
-    if (predictor_->initialization_state_ ==
+    if (resource_prefetch_predictor_->initialization_state_ ==
         ResourcePrefetchPredictor::INITIALIZED) {
       return;
     }
 
-    InitializationObserver observer(predictor_);
-    if (predictor_->initialization_state_ ==
+    InitializationObserver observer(resource_prefetch_predictor_);
+    if (resource_prefetch_predictor_->initialization_state_ ==
         ResourcePrefetchPredictor::NOT_INITIALIZED) {
-      predictor_->StartInitialization();
+      resource_prefetch_predictor_->StartInitialization();
     }
     observer.Wait();
   }
 
   URLRequestSummary GetURLRequestSummaryForResource(
       const GURL& main_frame_url,
       const ResourceSummary& resource_summary) const {
     URLRequestSummary summary(resource_summary.request);
     content::WebContents* web_contents =
         browser()->tab_strip_model()->GetActiveWebContents();
@@ skipping 109 matching lines @@
         base::MakeUnique<net::test_server::BasicHttpResponse>();
     http_response->set_code(redirect_it->second.code);
     http_response->AddCustomHeader("Location", redirect_it->second.url.spec());
     return std::move(http_response);
   }
 
   size_t UpdateAndGetVisitCount(const GURL& main_frame_url) {
     return ++visit_count_[main_frame_url];
   }
 
-  ResourcePrefetchPredictor* predictor_;
+  LoadingPredictor* predictor_;
+  ResourcePrefetchPredictor* resource_prefetch_predictor_;
   std::unique_ptr<net::EmbeddedTestServer> https_server_;
   std::map<GURL, ResourceSummary> resources_;
   std::map<GURL, RedirectEdge> redirects_;
   std::map<GURL, size_t> visit_count_;
   std::set<NavigationID> navigation_id_history_;
 };
 
-// Subclass to test PrefetchOrigin::NAVIGATION.
+// Subclass to test HintOrigin::NAVIGATION.
 class ResourcePrefetchPredictorPrefetchingBrowserTest
     : public ResourcePrefetchPredictorBrowserTest {
  protected:
   void SetUpCommandLine(base::CommandLine* command_line) override {
     command_line->AppendSwitchASCII("force-fieldtrials", "trial/group");
     std::string parameter = base::StringPrintf(
         "trial.group:%s/%s", kModeParamName, kPrefetchingMode);
     command_line->AppendSwitchASCII("force-fieldtrial-params", parameter);
     std::string enabled_feature = base::StringPrintf(
         "%s<trial", kSpeculativeResourcePrefetchingFeatureName);
@@ skipping 259 matching lines @@
   AddResourcesFromSubresourceHtml();
 
   NavigateToURLAndCheckSubresources(initial_url);
   ClearCache();
   NavigateToURLAndCheckSubresources(initial_url);
   ClearCache();
   NavigateToURLAndCheckPrefetching(initial_url);
 }
 
 }  // namespace predictors