Classify navigations without page id in parallel to the existing classifier.

content/test/test_render_frame_host.cc

 // Copyright 2013 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 "content/test/test_render_frame_host.h"
 
 #include "base/command_line.h"
 #include "content/browser/frame_host/frame_tree.h"
 #include "content/browser/frame_host/navigation_request.h"
 #include "content/browser/frame_host/navigator.h"
@@ skipping 61 matching lines @@
 }
 
 TestRenderFrameHost* TestRenderFrameHost::AppendChild(
     const std::string& frame_name) {
   OnCreateChildFrame(GetProcess()->GetNextRoutingID(), frame_name,
                      SandboxFlags::NONE);
   return static_cast<TestRenderFrameHost*>(
       child_creation_observer_.last_created_frame());
 }
 
-void TestRenderFrameHost::SendNavigateWithTransition(
-    int page_id,
-    const GURL& url,
-    ui::PageTransition transition) {
-  SendNavigateWithTransitionAndResponseCode(page_id, url, transition, 200);
-}
-
 void TestRenderFrameHost::SetContentsMimeType(const std::string& mime_type) {
   contents_mime_type_ = mime_type;
 }
 
 void TestRenderFrameHost::SendBeforeUnloadACK(bool proceed) {
   base::TimeTicks now = base::TimeTicks::Now();
   OnBeforeUnloadACK(proceed, now, now);
 }
 
 void TestRenderFrameHost::SimulateSwapOutACK() {
   OnSwappedOut();
 }
 
-void TestRenderFrameHost::SendNavigate(int page_id, const GURL& url) {
-  SendNavigateWithTransition(page_id, url, ui::PAGE_TRANSITION_LINK);
+void TestRenderFrameHost::SendNavigate(int page_id,
+                                       int nav_entry_id,
+                                       bool did_create_new_entry,
+                                       const GURL& url) {
+  SendNavigateWithTransition(page_id, nav_entry_id, did_create_new_entry, url,
+                             ui::PAGE_TRANSITION_LINK);
 }
 
-void TestRenderFrameHost::SendFailedNavigate(int page_id, const GURL& url) {
+void TestRenderFrameHost::SendFailedNavigate(int page_id,
+                                             int nav_entry_id,
+                                             bool did_create_new_entry,
+                                             const GURL& url) {
+  SendNavigateWithTransitionAndResponseCode(page_id, nav_entry_id,
+                                            did_create_new_entry, url,
+                                            ui::PAGE_TRANSITION_RELOAD, 500);
+}
+
+void TestRenderFrameHost::SendNavigateWithTransition(
+    int page_id,
+    int nav_entry_id,
+    bool did_create_new_entry,
+    const GURL& url,
+    ui::PageTransition transition) {
   SendNavigateWithTransitionAndResponseCode(
-      page_id, url, ui::PAGE_TRANSITION_RELOAD, 500);
+      page_id, nav_entry_id, did_create_new_entry, url, transition, 200);
 }
 
 void TestRenderFrameHost::SendNavigateWithTransitionAndResponseCode(
     int page_id,
-    const GURL& url, ui::PageTransition transition,
+    int nav_entry_id,
+    bool did_create_new_entry,
+    const GURL& url,
+    ui::PageTransition transition,
     int response_code) {
   // DidStartProvisionalLoad may delete the pending entry that holds |url|,
   // so we keep a copy of it to use in SendNavigateWithParameters.
   GURL url_copy(url);
 
   // Ensure that the RenderFrameCreated notification has been sent to observers
   // before navigating the frame.
   SetRenderFrameCreated(true);
 
   OnDidStartProvisionalLoadForFrame(url_copy, false);
-  SendNavigateWithParameters(page_id, url_copy, transition, url_copy,
-      response_code, 0, std::vector<GURL>());
+  SendNavigateWithParameters(page_id, nav_entry_id, did_create_new_entry,
+                             url_copy, transition, url_copy, response_code, 0,
+                             std::vector<GURL>());
 }
 
 void TestRenderFrameHost::SendNavigateWithOriginalRequestURL(
     int page_id,
+    int nav_entry_id,
+    bool did_create_new_entry,
     const GURL& url,
     const GURL& original_request_url) {
   // Ensure that the RenderFrameCreated notification has been sent to observers
   // before navigating the frame.
   SetRenderFrameCreated(true);
 
   OnDidStartProvisionalLoadForFrame(url, false);
-  SendNavigateWithParameters(page_id, url, ui::PAGE_TRANSITION_LINK,
-      original_request_url, 200, 0, std::vector<GURL>());
+  SendNavigateWithParameters(page_id, nav_entry_id, did_create_new_entry, url,
+                             ui::PAGE_TRANSITION_LINK, original_request_url,
+                             200, 0, std::vector<GURL>());
 }
 
 void TestRenderFrameHost::SendNavigateWithFile(
     int page_id,
+    int nav_entry_id,
+    bool did_create_new_entry,
     const GURL& url,
     const base::FilePath& file_path) {
-  SendNavigateWithParameters(page_id, url, ui::PAGE_TRANSITION_LINK, url, 200,
-      &file_path, std::vector<GURL>());
+  SendNavigateWithParameters(page_id, nav_entry_id, did_create_new_entry, url,
+                             ui::PAGE_TRANSITION_LINK, url, 200, &file_path,
+                             std::vector<GURL>());
 }
 
 void TestRenderFrameHost::SendNavigateWithParams(
     FrameHostMsg_DidCommitProvisionalLoad_Params* params) {
   FrameHostMsg_DidCommitProvisionalLoad msg(GetRoutingID(), *params);
   OnDidCommitProvisionalLoad(msg);
 }
 
 void TestRenderFrameHost::SendNavigateWithRedirects(
     int page_id,
+    int nav_entry_id,
+    bool did_create_new_entry,
     const GURL& url,
     const std::vector<GURL>& redirects) {
-  SendNavigateWithParameters(
-      page_id, url, ui::PAGE_TRANSITION_LINK, url, 200, 0, redirects);
+  SendNavigateWithParameters(page_id, nav_entry_id, did_create_new_entry, url,
+                             ui::PAGE_TRANSITION_LINK, url, 200, 0, redirects);
 }
 
 void TestRenderFrameHost::SendNavigateWithParameters(
     int page_id,
+    int nav_entry_id,
+    bool did_create_new_entry,
     const GURL& url,
     ui::PageTransition transition,
     const GURL& original_request_url,
     int response_code,
     const base::FilePath* file_path_for_history_item,
     const std::vector<GURL>& redirects) {
   FrameHostMsg_DidCommitProvisionalLoad_Params params;
   params.page_id = page_id;
+  params.nav_entry_id = nav_entry_id;
   params.url = url;
   params.referrer = Referrer();
   params.transition = transition;
   params.redirects = redirects;
   params.should_update_history = true;
   params.searchable_form_url = GURL();
   params.searchable_form_encoding = std::string();
+  params.did_create_new_entry = did_create_new_entry;
   params.security_info = std::string();
   params.gesture = NavigationGestureUser;
   params.contents_mime_type = contents_mime_type_;
   params.is_post = false;
   params.http_status_code = response_code;
   params.socket_address.set_host("2001:db8::1");
   params.socket_address.set_port(80);
   params.history_list_was_cleared = simulate_history_list_was_cleared_;
   params.original_request_url = original_request_url;
 
   url::Replacements<char> replacements;
   replacements.ClearRef();
   params.was_within_same_page = transition != ui::PAGE_TRANSITION_RELOAD &&
       transition != ui::PAGE_TRANSITION_TYPED &&
       url.ReplaceComponents(replacements) ==
           GetLastCommittedURL().ReplaceComponents(replacements);
 
   params.page_state = PageState::CreateForTesting(
       url,
       false,
       file_path_for_history_item ? "data" : NULL,
       file_path_for_history_item);
 
   FrameHostMsg_DidCommitProvisionalLoad msg(GetRoutingID(), params);
   OnDidCommitProvisionalLoad(msg);
 }
 
-void TestRenderFrameHost::NavigateAndCommitRendererInitiated(int page_id,
-                                                             const GURL& url) {
+void TestRenderFrameHost::NavigateAndCommitRendererInitiated(
+    int page_id,
+    bool did_create_new_entry,
+    const GURL& url) {
   SendRendererInitiatedNavigationRequest(url, false);
   PrepareForCommit();
-  SendNavigate(page_id, url);
+  SendNavigate(page_id, 0, did_create_new_entry, url);
 }
 
 void TestRenderFrameHost::SendRendererInitiatedNavigationRequest(
     const GURL& url,
     bool has_user_gesture) {
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableBrowserSideNavigation)) {
     BeginNavigationParams begin_params("GET", std::string(), net::LOAD_NORMAL,
                                        has_user_gesture);
     CommonNavigationParams common_params;
@@ skipping 50 matching lines @@
     url_loader->SimulateServerRedirect(redirect_url);
 
   // Simulate the network stack commit.
   scoped_refptr<ResourceResponse> response(new ResourceResponse);
   // TODO(carlosk): ideally with PlzNavigate it should be possible someday to
   // fully commit the navigation at this call to CallOnResponseStarted.
   url_loader->CallOnResponseStarted(response, MakeEmptyStream());
 }
 
 }  // namespace content