DRAFT CL: Add FrameNavigationEntry and track subframe session histories.

content/browser/frame_host/navigator_impl.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/browser/frame_host/navigator_impl.h"
 
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "base/time/time.h"
 #include "content/browser/frame_host/frame_tree.h"
@@ skipping 233 matching lines @@
     const base::string16& error_description) {
   if (delegate_) {
     delegate_->DidFailLoadWithError(
         render_frame_host, url, error_code,
         error_description);
   }
 }
 
 bool NavigatorImpl::NavigateToEntry(
     FrameTreeNode* frame_tree_node,
+    const FrameNavigationEntry& frame_nav_entry,
     const NavigationEntryImpl& entry,
     NavigationController::ReloadType reload_type) {
   TRACE_EVENT0("browser,navigation", "NavigatorImpl::NavigateToEntry");
 
   // The renderer will reject IPC messages with URLs longer than
   // this limit, so don't attempt to navigate with a longer URL.
-  if (entry.GetURL().spec().size() > GetMaxURLChars()) {
+  if (frame_nav_entry.url().spec().size() > GetMaxURLChars()) {
     LOG(WARNING) << "Refusing to load URL as it exceeds " << GetMaxURLChars()
                  << " characters.";
     return false;
   }
 
   // This will be used to set the Navigation Timing API navigationStart
   // parameter for browser navigations in new tabs (intents, tabs opened through
   // "Open link in new tab"). We need to keep it above RFHM::Navigate() call to
   // capture the time needed for the RenderFrameHost initialization.
   base::TimeTicks navigation_start = base::TimeTicks::Now();
 
   RenderFrameHostManager* manager = frame_tree_node->render_manager();
 
   // PlzNavigate: the RenderFrameHosts are no longer asked to navigate.
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableBrowserSideNavigation)) {
     navigation_data_.reset(new NavigationMetricsData(
-        navigation_start, entry.GetURL(), entry.restore_type()));
-    RequestNavigation(frame_tree_node, entry, reload_type, navigation_start);
+        navigation_start, frame_nav_entry.url(), entry.restore_type()));
+    RequestNavigation(frame_tree_node, frame_nav_entry, entry, reload_type,
+                      navigation_start);
     return true;
   }
 
-  RenderFrameHostImpl* dest_render_frame_host = manager->Navigate(entry);
+  RenderFrameHostImpl* dest_render_frame_host =
+      manager->Navigate(frame_nav_entry, entry);
   if (!dest_render_frame_host)
     return false;  // Unable to create the desired RenderFrameHost.
 
   // Make sure no code called via RFHM::Navigate clears the pending entry.
   CHECK_EQ(controller_->GetPendingEntry(), &entry);
 
   // For security, we should never send non-Web-UI URLs to a Web UI renderer.
   // Double check that here.
   CheckWebUIRendererDoesNotDisplayNormalURL(
-      dest_render_frame_host, entry.GetURL());
+      dest_render_frame_host, frame_nav_entry.url());
 
   // Notify observers that we will navigate in this RenderFrame.
   if (delegate_) {
+    // TODO(creis): Deprecate this API.  We should not be accessing the current
+    // RFH here.
     delegate_->AboutToNavigateRenderFrame(frame_tree_node->current_frame_host(),
                                           dest_render_frame_host);
   }
 
   // Navigate in the desired RenderFrameHost.
   // We can skip this step in the rare case that this is a transfer navigation
   // which began in the chosen RenderFrameHost, since the request has already
   // been issued.  In that case, simply resume the response.
   bool is_transfer_to_same =
       entry.transferred_global_request_id().child_id != -1 &&
       entry.transferred_global_request_id().child_id ==
           dest_render_frame_host->GetProcess()->GetID();
   if (!is_transfer_to_same) {
     navigation_data_.reset(new NavigationMetricsData(
-        navigation_start, entry.GetURL(), entry.restore_type()));
+        navigation_start, frame_nav_entry.url(), entry.restore_type()));
     // Create the navigation parameters.
     // TODO(vitalybuka): Move this before AboutToNavigateRenderFrame once
     // http://crbug.com/408684 is fixed.
     FrameMsg_Navigate_Type::Value navigation_type =
         GetNavigationType(controller_->GetBrowserContext(), entry, reload_type);
     dest_render_frame_host->Navigate(
-        entry.ConstructCommonNavigationParams(navigation_type),
+        entry.ConstructCommonNavigationParams(frame_nav_entry, navigation_type),
         entry.ConstructStartNavigationParams(),
         entry.ConstructCommitNavigationParams(navigation_start),
-        entry.ConstructHistoryNavigationParams(controller_));
+        entry.ConstructHistoryNavigationParams(frame_nav_entry, controller_));
   } else {
     // No need to navigate again.  Just resume the deferred request.
     dest_render_frame_host->GetProcess()->ResumeDeferredNavigation(
         entry.transferred_global_request_id());
   }
 
   // Make sure no code called via RFH::Navigate clears the pending entry.
   CHECK_EQ(controller_->GetPendingEntry(), &entry);
 
   if (entry.GetPageID() == -1) {
     // HACK!!  This code suppresses javascript: URLs from being added to
     // session history, which is what we want to do for javascript: URLs that
     // do not generate content.  What we really need is a message from the
     // renderer telling us that a new page was not created.  The same message
     // could be used for mailto: URLs and the like.
-    if (entry.GetURL().SchemeIs(url::kJavaScriptScheme))
+    if (frame_nav_entry.url().SchemeIs(url::kJavaScriptScheme))
       return false;
   }
 
   // Notify observers about navigation.
-  if (delegate_)
-    delegate_->DidStartNavigationToPendingEntry(entry.GetURL(), reload_type);
+  if (delegate_) {
+    delegate_->DidStartNavigationToPendingEntry(frame_nav_entry.url(),
+                                                reload_type);
+  }
 
   return true;
 }
 
 bool NavigatorImpl::NavigateToPendingEntry(
     FrameTreeNode* frame_tree_node,
+    const FrameNavigationEntry& frame_nav_entry,
     NavigationController::ReloadType reload_type) {
-  return NavigateToEntry(frame_tree_node, *controller_->GetPendingEntry(),
-                         reload_type);
+  return NavigateToEntry(frame_tree_node, frame_nav_entry,
+                         *controller_->GetPendingEntry(), reload_type);
 }
 
 void NavigatorImpl::DidNavigate(
     RenderFrameHostImpl* render_frame_host,
     const FrameHostMsg_DidCommitProvisionalLoad_Params& input_params) {
   // PlzNavigate
   // The navigation request has been committed so the browser process doesn't
   // need to care about it anymore.
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableBrowserSideNavigation)) {
@@ skipping 71 matching lines @@
   // TODO(nasko): Verify the correctness of the above comment, since some of the
   // code doesn't exist anymore. Also, move this code in the
   // PageTransitionIsMainFrame code block above.
   if (ui::PageTransitionIsMainFrame(params.transition) && delegate_)
     delegate_->SetMainFrameMimeType(params.contents_mime_type);
 
   LoadCommittedDetails details;
   bool did_navigate = controller_->RendererDidNavigate(render_frame_host,
                                                        params, &details);
 
-  // For now, keep track of each frame's URL in its FrameTreeNode.  This lets
-  // us estimate our process count for implementing OOP iframes.
-  // TODO(creis): Remove this when we track which pages commit in each frame.
-  render_frame_host->frame_tree_node()->set_current_url(params.url);
-
   // Send notification about committed provisional loads. This notification is
   // different from the NAV_ENTRY_COMMITTED notification which doesn't include
   // the actual URL navigated to and isn't sent for AUTO_SUBFRAME navigations.
   if (details.type != NAVIGATION_TYPE_NAV_IGNORE && delegate_) {
     DCHECK_EQ(!render_frame_host->GetParent(),
               did_navigate ? details.is_main_frame : false);
     ui::PageTransition transition_type = params.transition;
     // Whether or not a page transition was triggered by going backward or
     // forward in the history is only stored in the navigation controller's
     // entry list.
@@ skipping 308 matching lines @@
       !is_allowed_in_web_ui_renderer) {
     // Log the URL to help us diagnose any future failures of this CHECK.
     GetContentClient()->SetActiveURL(url);
     CHECK(0);
   }
 }
 
 // PlzNavigate
 void NavigatorImpl::RequestNavigation(
     FrameTreeNode* frame_tree_node,
+    const FrameNavigationEntry& frame_entry,
     const NavigationEntryImpl& entry,
     NavigationController::ReloadType reload_type,
     base::TimeTicks navigation_start) {
   CHECK(base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableBrowserSideNavigation));
   DCHECK(frame_tree_node);
   int64 frame_tree_node_id = frame_tree_node->frame_tree_node_id();
   FrameMsg_Navigate_Type::Value navigation_type =
       GetNavigationType(controller_->GetBrowserContext(), entry, reload_type);
+  // TODO(creis): Pass frame_entry and get the URL and referrer from there.
   scoped_ptr<NavigationRequest> navigation_request =
       NavigationRequest::CreateBrowserInitiated(frame_tree_node, entry,
                                                 navigation_type,
                                                 navigation_start, controller_);
   // TODO(clamy): Check if navigations are blocked and if so store the
   // parameters.
 
   // If there is an ongoing request, cancel and replace it.
   NavigationRequest* ongoing_request =
       navigation_request_map_.get(frame_tree_node->frame_tree_node_id());
@@ skipping 77 matching lines @@
         "Navigation.TimeToCommit_ExistingRenderer_BeforeUnloadDiscounted",
         time_to_commit);
     UMA_HISTOGRAM_TIMES(
         "Navigation.TimeToURLJobStart_ExistingRenderer_BeforeUnloadDiscounted",
         time_to_network);
   }
   navigation_data_.reset();
 }
 
 }  // namespace content