predictors: Make speculative_prefetch_predictor work with PlzNavigate

chrome/browser/predictors/resource_prefetch_predictor_test_util.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 "chrome/browser/predictors/resource_prefetch_predictor_test_util.h"
 
 #include "chrome/browser/predictors/resource_prefetch_predictor_tables.h"
 
 namespace predictors {
 
@@ skipping 42 matching lines @@
 }
 
 RedirectData CreateRedirectData(const std::string& primary_key,
                                 uint64_t last_visit_time) {
   RedirectData data;
   data.set_primary_key(primary_key);
   data.set_last_visit_time(last_visit_time);
   return data;
 }
 
-NavigationID CreateNavigationID(int process_id,
-                                int render_frame_id,
+NavigationID CreateNavigationID(int session_id,
                                 const std::string& main_frame_url) {
   NavigationID navigation_id;
-  navigation_id.render_process_id = process_id;
-  navigation_id.render_frame_id = render_frame_id;
+  navigation_id.session_id.set_id(session_id);
   navigation_id.main_frame_url = GURL(main_frame_url);
   navigation_id.creation_time = base::TimeTicks::Now();
   return navigation_id;
 }
 
 PageRequestSummary CreatePageRequestSummary(
     const std::string& main_frame_url,
     const std::string& initial_url,
     const std::vector<URLRequestSummary>& subresource_requests) {
   GURL main_frame_gurl(main_frame_url);
   PageRequestSummary summary(main_frame_gurl);
   summary.initial_url = GURL(initial_url);
   summary.subresource_requests = subresource_requests;
   return summary;
 }
 
-URLRequestSummary CreateURLRequestSummary(int process_id,
-                                          int render_frame_id,
+URLRequestSummary CreateURLRequestSummary(int tab_id,
                                           const std::string& main_frame_url,
                                           const std::string& resource_url,
                                           content::ResourceType resource_type,
                                           net::RequestPriority priority,
                                           const std::string& mime_type,
                                           bool was_cached,
                                           const std::string& redirect_url,
                                           bool has_validators,
                                           bool always_revalidate) {
   URLRequestSummary summary;
-  summary.navigation_id =
-      CreateNavigationID(process_id, render_frame_id, main_frame_url);
+  summary.navigation_id = CreateNavigationID(tab_id, main_frame_url);
   summary.resource_url =
       resource_url.empty() ? GURL(main_frame_url) : GURL(resource_url);
   summary.resource_type = resource_type;
   summary.priority = priority;
   summary.mime_type = mime_type;
   summary.was_cached = was_cached;
   if (!redirect_url.empty())
     summary.redirect_url = GURL(redirect_url);
   summary.has_validators = has_validators;
   summary.always_revalidate = always_revalidate;
@@ skipping 42 matching lines @@
 
 std::ostream& operator<<(std::ostream& os, const URLRequestSummary& summary) {
   return os << "[" << summary.navigation_id << "," << summary.resource_url
             << "," << summary.resource_type << "," << summary.priority << ","
             << summary.mime_type << "," << summary.was_cached << ","
             << summary.redirect_url << "," << summary.has_validators << ","
             << summary.always_revalidate << "]";
 }
 
 std::ostream& operator<<(std::ostream& os, const NavigationID& navigation_id) {
-  return os << navigation_id.render_process_id << ","
-            << navigation_id.render_frame_id << ","
+  return os << navigation_id.session_id.id() << ","
             << navigation_id.main_frame_url;
 }
 
+std::ostream& operator<<(
+    std::ostream& os,
+    const std::map<NavigationID, std::unique_ptr<PageRequestSummary>>& map) {
+  os << "Navigation Map, " << map.size() << " elements" << std::endl;
+  int i = 0;
+  for (auto nav_it = map.begin(); nav_it != map.end(); ++nav_it, ++i)
+    os << "Element " << i << ": " << nav_it->first << std::endl;
+  return os;
+}
+
 bool operator==(const PrefetchData& lhs, const PrefetchData& rhs) {
   bool equal = lhs.primary_key() == rhs.primary_key() &&
                lhs.resources_size() == rhs.resources_size();
 
   if (!equal)
     return false;
 
   for (int i = 0; i < lhs.resources_size(); ++i)
     equal = equal && lhs.resources(i) == rhs.resources(i);
 
@@ skipping 43 matching lines @@
          lhs.resource_url == rhs.resource_url &&
          lhs.resource_type == rhs.resource_type &&
          lhs.priority == rhs.priority && lhs.mime_type == rhs.mime_type &&
          lhs.was_cached == rhs.was_cached &&
          lhs.redirect_url == rhs.redirect_url &&
          lhs.has_validators == rhs.has_validators &&
          lhs.always_revalidate == rhs.always_revalidate;
 }
 
 }  // namespace predictors