content/browser/frame_host/navigator_impl.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/browser/frame_host/navigator_impl.h"
   6
   7 #include "base/command_line.h"
   8 #include "content/browser/frame_host/frame_tree.h"
   9 #include "content/browser/frame_host/frame_tree_node.h"
  10 #include "content/browser/frame_host/navigation_controller_impl.h"
  11 #include "content/browser/frame_host/navigation_entry_impl.h"
  12 #include "content/browser/frame_host/navigator_delegate.h"
  13 #include "content/browser/frame_host/render_frame_host_impl.h"
  14 #include "content/browser/renderer_host/render_view_host_impl.h"
  15 #include "content/browser/site_instance_impl.h"
  16 #include "content/browser/webui/web_ui_controller_factory_registry.h"
  17 #include "content/browser/webui/web_ui_impl.h"
  18 #include "content/common/frame_messages.h"
  19 #include "content/common/view_messages.h"
  20 #include "content/public/browser/browser_context.h"
  21 #include "content/public/browser/content_browser_client.h"
  22 #include "content/public/browser/global_request_id.h"
  23 #include "content/public/browser/invalidate_type.h"
  24 #include "content/public/browser/navigation_controller.h"
  25 #include "content/public/browser/navigation_details.h"
  26 #include "content/public/browser/page_navigator.h"
  27 #include "content/public/browser/render_view_host.h"
  28 #include "content/public/common/bindings_policy.h"
  29 #include "content/public/common/content_client.h"
  30 #include "content/public/common/content_switches.h"
  31 #include "content/public/common/url_constants.h"
  32 #include "content/public/common/url_utils.h"
  33
  34 namespace content {
  35
  36 namespace {
  37
  38 FrameMsg_Navigate_Type::Value GetNavigationType(
  39     BrowserContext* browser_context, const NavigationEntryImpl& entry,
  40     NavigationController::ReloadType reload_type) {
  41   switch (reload_type) {
  42     case NavigationControllerImpl::RELOAD:
  43       return FrameMsg_Navigate_Type::RELOAD;
  44     case NavigationControllerImpl::RELOAD_IGNORING_CACHE:
  45       return FrameMsg_Navigate_Type::RELOAD_IGNORING_CACHE;
  46     case NavigationControllerImpl::RELOAD_ORIGINAL_REQUEST_URL:
  47       return FrameMsg_Navigate_Type::RELOAD_ORIGINAL_REQUEST_URL;
  48     case NavigationControllerImpl::NO_RELOAD:
  49       break;  // Fall through to rest of function.
  50   }
  51
  52   // |RenderViewImpl::PopulateStateFromPendingNavigationParams| differentiates
  53   // between |RESTORE_WITH_POST| and |RESTORE|.
  54   if (entry.restore_type() ==
  55       NavigationEntryImpl::RESTORE_LAST_SESSION_EXITED_CLEANLY) {
  56     if (entry.GetHasPostData())
  57       return FrameMsg_Navigate_Type::RESTORE_WITH_POST;
  58     return FrameMsg_Navigate_Type::RESTORE;
  59   }
  60
  61   return FrameMsg_Navigate_Type::NORMAL;
  62 }
  63
  64 void MakeNavigateParams(const NavigationEntryImpl& entry,
  65                         const NavigationControllerImpl& controller,
  66                         NavigationController::ReloadType reload_type,
  67                         FrameMsg_Navigate_Params* params) {
  68   params->page_id = entry.GetPageID();
  69   params->should_clear_history_list = entry.should_clear_history_list();
  70   params->should_replace_current_entry = entry.should_replace_entry();
  71   if (entry.should_clear_history_list()) {
  72     // Set the history list related parameters to the same values a
  73     // NavigationController would return before its first navigation. This will
  74     // fully clear the RenderView's view of the session history.
  75     params->pending_history_list_offset = -1;
  76     params->current_history_list_offset = -1;
  77     params->current_history_list_length = 0;
  78   } else {
  79     params->pending_history_list_offset = controller.GetIndexOfEntry(&entry);
  80     params->current_history_list_offset =
  81         controller.GetLastCommittedEntryIndex();
  82     params->current_history_list_length = controller.GetEntryCount();
  83   }
  84   params->url = entry.GetURL();
  85   if (!entry.GetBaseURLForDataURL().is_empty()) {
  86     params->base_url_for_data_url = entry.GetBaseURLForDataURL();
  87     params->history_url_for_data_url = entry.GetVirtualURL();
  88   }
  89   params->referrer = entry.GetReferrer();
  90   params->transition = entry.GetTransitionType();
  91   params->page_state = entry.GetPageState();
  92   params->navigation_type =
  93       GetNavigationType(controller.GetBrowserContext(), entry, reload_type);
  94   params->request_time = base::Time::Now();
  95   params->extra_headers = entry.extra_headers();
  96   params->transferred_request_child_id =
  97       entry.transferred_global_request_id().child_id;
  98   params->transferred_request_request_id =
  99       entry.transferred_global_request_id().request_id;
 100   params->is_overriding_user_agent = entry.GetIsOverridingUserAgent();
 101   // Avoid downloading when in view-source mode.
 102   params->allow_download = !entry.IsViewSourceMode();
 103   params->is_post = entry.GetHasPostData();
 104   if (entry.GetBrowserInitiatedPostData()) {
 105     params->browser_initiated_post_data.assign(
 106         entry.GetBrowserInitiatedPostData()->front(),
 107         entry.GetBrowserInitiatedPostData()->front() +
 108             entry.GetBrowserInitiatedPostData()->size());
 109   }
 110
 111   params->redirects = entry.redirect_chain();
 112
 113   params->can_load_local_resources = entry.GetCanLoadLocalResources();
 114   params->frame_to_navigate = entry.GetFrameToNavigate();
 115 }
 116
 117 RenderFrameHostManager* GetRenderManager(RenderFrameHostImpl* rfh) {
 118   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kSitePerProcess))
 119     return rfh->frame_tree_node()->render_manager();
 120
 121   return rfh->frame_tree_node()->frame_tree()->root()->render_manager();
 122 }
 123
 124 }  // namespace
 125
 126
 127 NavigatorImpl::NavigatorImpl(
 128     NavigationControllerImpl* navigation_controller,
 129     NavigatorDelegate* delegate)
 130     : controller_(navigation_controller),
 131       delegate_(delegate) {
 132 }
 133
 134 void NavigatorImpl::DidStartProvisionalLoad(
 135     RenderFrameHostImpl* render_frame_host,
 136     int parent_routing_id,
 137     bool is_main_frame,
 138     const GURL& url) {
 139   bool is_error_page = (url.spec() == kUnreachableWebDataURL);
 140   bool is_iframe_srcdoc = (url.spec() == kAboutSrcDocURL);
 141   GURL validated_url(url);
 142   RenderProcessHost* render_process_host = render_frame_host->GetProcess();
 143   render_process_host->FilterURL(false, &validated_url);
 144
 145   // TODO(creis): This is a hack for now, until we mirror the frame tree and do
 146   // cross-process subframe navigations in actual subframes.  As a result, we
 147   // can currently only support a single cross-process subframe per RVH.
 148   NavigationEntryImpl* pending_entry =
 149       NavigationEntryImpl::FromNavigationEntry(controller_->GetPendingEntry());
 150   if (pending_entry &&
 151       pending_entry->frame_tree_node_id() != -1 &&
 152       CommandLine::ForCurrentProcess()->HasSwitch(switches::kSitePerProcess))
 153     is_main_frame = false;
 154
 155   if (is_main_frame) {
 156     // If there is no browser-initiated pending entry for this navigation and it
 157     // is not for the error URL, create a pending entry using the current
 158     // SiteInstance, and ensure the address bar updates accordingly.  We don't
 159     // know the referrer or extra headers at this point, but the referrer will
 160     // be set properly upon commit.
 161     bool has_browser_initiated_pending_entry = pending_entry &&
 162         !pending_entry->is_renderer_initiated();
 163     if (!has_browser_initiated_pending_entry && !is_error_page) {
 164       NavigationEntryImpl* entry = NavigationEntryImpl::FromNavigationEntry(
 165           controller_->CreateNavigationEntry(validated_url,
 166                                              content::Referrer(),
 167                                              content::PAGE_TRANSITION_LINK,
 168                                              true /* is_renderer_initiated */,
 169                                              std::string(),
 170                                              controller_->GetBrowserContext()));
 171       entry->set_site_instance(
 172           static_cast<SiteInstanceImpl*>(
 173               render_frame_host->render_view_host()->GetSiteInstance()));
 174       // TODO(creis): If there's a pending entry already, find a safe way to
 175       // update it instead of replacing it and copying over things like this.
 176       if (pending_entry) {
 177         entry->set_transferred_global_request_id(
 178             pending_entry->transferred_global_request_id());
 179         entry->set_should_replace_entry(pending_entry->should_replace_entry());
 180         entry->set_redirect_chain(pending_entry->redirect_chain());
 181       }
 182       controller_->SetPendingEntry(entry);
 183       if (delegate_)
 184         delegate_->NotifyChangedNavigationState(content::INVALIDATE_TYPE_URL);
 185     }
 186   }
 187
 188   if (delegate_) {
 189     // Notify the observer about the start of the provisional load.
 190     delegate_->DidStartProvisionalLoad(
 191         render_frame_host, parent_routing_id, is_main_frame,
 192         validated_url, is_error_page, is_iframe_srcdoc);
 193   }
 194 }
 195
 196
 197 void NavigatorImpl::DidFailProvisionalLoadWithError(
 198     RenderFrameHostImpl* render_frame_host,
 199     const FrameHostMsg_DidFailProvisionalLoadWithError_Params& params) {
 200   VLOG(1) << "Failed Provisional Load: " << params.url.possibly_invalid_spec()
 201           << ", error_code: " << params.error_code
 202           << ", error_description: " << params.error_description
 203           << ", is_main_frame: " << params.is_main_frame
 204           << ", showing_repost_interstitial: " <<
 205             params.showing_repost_interstitial
 206           << ", frame_id: " << render_frame_host->GetRoutingID();
 207   GURL validated_url(params.url);
 208   RenderProcessHost* render_process_host = render_frame_host->GetProcess();
 209   render_process_host->FilterURL(false, &validated_url);
 210
 211   if (net::ERR_ABORTED == params.error_code) {
 212     // EVIL HACK ALERT! Ignore failed loads when we're showing interstitials.
 213     // This means that the interstitial won't be torn down properly, which is
 214     // bad. But if we have an interstitial, go back to another tab type, and
 215     // then load the same interstitial again, we could end up getting the first
 216     // interstitial's "failed" message (as a result of the cancel) when we're on
 217     // the second one. We can't tell this apart, so we think we're tearing down
 218     // the current page which will cause a crash later on.
 219     //
 220     // http://code.google.com/p/chromium/issues/detail?id=2855
 221     // Because this will not tear down the interstitial properly, if "back" is
 222     // back to another tab type, the interstitial will still be somewhat alive
 223     // in the previous tab type. If you navigate somewhere that activates the
 224     // tab with the interstitial again, you'll see a flash before the new load
 225     // commits of the interstitial page.
 226     FrameTreeNode* root =
 227         render_frame_host->frame_tree_node()->frame_tree()->root();
 228     if (root->render_manager()->interstitial_page() != NULL) {
 229       LOG(WARNING) << "Discarding message during interstitial.";
 230       return;
 231     }
 232
 233     // We used to cancel the pending renderer here for cross-site downloads.
 234     // However, it's not safe to do that because the download logic repeatedly
 235     // looks for this WebContents based on a render ID.  Instead, we just
 236     // leave the pending renderer around until the next navigation event
 237     // (Navigate, DidNavigate, etc), which will clean it up properly.
 238     //
 239     // TODO(creis): Find a way to cancel any pending RFH here.
 240   }
 241
 242   // Do not usually clear the pending entry if one exists, so that the user's
 243   // typed URL is not lost when a navigation fails or is aborted.  However, in
 244   // cases that we don't show the pending entry (e.g., renderer-initiated
 245   // navigations in an existing tab), we don't keep it around.  That prevents
 246   // spoofs on in-page navigations that don't go through
 247   // DidStartProvisionalLoadForFrame.
 248   // In general, we allow the view to clear the pending entry and typed URL if
 249   // the user requests (e.g., hitting Escape with focus in the address bar).
 250   // Note: don't touch the transient entry, since an interstitial may exist.
 251   if (controller_->GetPendingEntry() != controller_->GetVisibleEntry())
 252     controller_->DiscardPendingEntry();
 253
 254   delegate_->DidFailProvisionalLoadWithError(render_frame_host, params);
 255 }
 256
 257 void NavigatorImpl::DidFailLoadWithError(
 258     RenderFrameHostImpl* render_frame_host,
 259     const GURL& url,
 260     bool is_main_frame,
 261     int error_code,
 262     const base::string16& error_description) {
 263   delegate_->DidFailLoadWithError(
 264       render_frame_host, url, is_main_frame, error_code,
 265       error_description);
 266 }
 267
 268 void NavigatorImpl::DidRedirectProvisionalLoad(
 269     RenderFrameHostImpl* render_frame_host,
 270     int32 page_id,
 271     const GURL& source_url,
 272     const GURL& target_url) {
 273   // TODO(creis): Remove this method and have the pre-rendering code listen to
 274   // WebContentsObserver::DidGetRedirectForResourceRequest instead.
 275   // See http://crbug.com/78512.
 276   GURL validated_source_url(source_url);
 277   GURL validated_target_url(target_url);
 278   RenderProcessHost* render_process_host = render_frame_host->GetProcess();
 279   render_process_host->FilterURL(false, &validated_source_url);
 280   render_process_host->FilterURL(false, &validated_target_url);
 281   NavigationEntry* entry;
 282   if (page_id == -1) {
 283     entry = controller_->GetPendingEntry();
 284   } else {
 285     entry = controller_->GetEntryWithPageID(
 286         render_frame_host->GetSiteInstance(), page_id);
 287   }
 288   if (!entry || entry->GetURL() != validated_source_url)
 289     return;
 290
 291   delegate_->DidRedirectProvisionalLoad(
 292       render_frame_host, validated_target_url);
 293 }
 294
 295 bool NavigatorImpl::NavigateToEntry(
 296     RenderFrameHostImpl* render_frame_host,
 297     const NavigationEntryImpl& entry,
 298     NavigationController::ReloadType reload_type) {
 299   TRACE_EVENT0("browser", "NavigatorImpl::NavigateToEntry");
 300
 301   // The renderer will reject IPC messages with URLs longer than
 302   // this limit, so don't attempt to navigate with a longer URL.
 303   if (entry.GetURL().spec().size() > GetMaxURLChars()) {
 304     LOG(WARNING) << "Refusing to load URL as it exceeds " << GetMaxURLChars()
 305                  << " characters.";
 306     return false;
 307   }
 308
 309   // Use entry->frame_tree_node_id() to pick which RenderFrameHostManager to
 310   // use when --site-per-process is used.
 311   RenderFrameHostManager* manager =
 312       render_frame_host->frame_tree_node()->render_manager();
 313   if (entry.frame_tree_node_id() != -1 &&
 314       CommandLine::ForCurrentProcess()->HasSwitch(switches::kSitePerProcess)) {
 315     int64 frame_tree_node_id = entry.frame_tree_node_id();
 316     manager = render_frame_host->frame_tree_node()->frame_tree()->FindByID(
 317         frame_tree_node_id)->render_manager();
 318   }
 319
 320   RenderFrameHostImpl* dest_render_frame_host = manager->Navigate(entry);
 321   if (!dest_render_frame_host)
 322     return false;  // Unable to create the desired RenderFrameHost.
 323
 324   // Make sure no code called via RFHM::Navigate clears the pending entry.
 325   CHECK_EQ(controller_->GetPendingEntry(), &entry);
 326
 327   // For security, we should never send non-Web-UI URLs to a Web UI renderer.
 328   // Double check that here.
 329   int enabled_bindings =
 330       dest_render_frame_host->render_view_host()->GetEnabledBindings();
 331   bool is_allowed_in_web_ui_renderer =
 332       WebUIControllerFactoryRegistry::GetInstance()->IsURLAcceptableForWebUI(
 333           controller_->GetBrowserContext(), entry.GetURL());
 334   if ((enabled_bindings & BINDINGS_POLICY_WEB_UI) &&
 335       !is_allowed_in_web_ui_renderer) {
 336     // Log the URL to help us diagnose any future failures of this CHECK.
 337     GetContentClient()->SetActiveURL(entry.GetURL());
 338     CHECK(0);
 339   }
 340
 341   // Notify observers that we will navigate in this RenderFrame.
 342   if (delegate_)
 343     delegate_->AboutToNavigateRenderFrame(dest_render_frame_host);
 344
 345   // Used for page load time metrics.
 346   current_load_start_ = base::TimeTicks::Now();
 347
 348   // Navigate in the desired RenderFrameHost.
 349   // TODO(creis): As a temporary hack, we currently do cross-process subframe
 350   // navigations in a top-level frame of the new process.  Thus, we don't yet
 351   // need to store the correct frame ID in FrameMsg_Navigate_Params.
 352   FrameMsg_Navigate_Params navigate_params;
 353   MakeNavigateParams(entry, *controller_, reload_type, &navigate_params);
 354   dest_render_frame_host->Navigate(navigate_params);
 355
 356   // Make sure no code called via RFH::Navigate clears the pending entry.
 357   CHECK_EQ(controller_->GetPendingEntry(), &entry);
 358
 359   if (entry.GetPageID() == -1) {
 360     // HACK!!  This code suppresses javascript: URLs from being added to
 361     // session history, which is what we want to do for javascript: URLs that
 362     // do not generate content.  What we really need is a message from the
 363     // renderer telling us that a new page was not created.  The same message
 364     // could be used for mailto: URLs and the like.
 365     if (entry.GetURL().SchemeIs(kJavaScriptScheme))
 366       return false;
 367   }
 368
 369   // Notify observers about navigation.
 370   if (delegate_) {
 371     delegate_->DidStartNavigationToPendingEntry(render_frame_host,
 372                                                 entry.GetURL(),
 373                                                 reload_type);
 374   }
 375
 376   return true;
 377 }
 378
 379 bool NavigatorImpl::NavigateToPendingEntry(
 380     RenderFrameHostImpl* render_frame_host,
 381     NavigationController::ReloadType reload_type) {
 382   return NavigateToEntry(
 383       render_frame_host,
 384       *NavigationEntryImpl::FromNavigationEntry(controller_->GetPendingEntry()),
 385       reload_type);
 386 }
 387
 388 base::TimeTicks NavigatorImpl::GetCurrentLoadStart() {
 389   return current_load_start_;
 390 }
 391
 392 void NavigatorImpl::DidNavigate(
 393     RenderFrameHostImpl* render_frame_host,
 394     const FrameHostMsg_DidCommitProvisionalLoad_Params& input_params) {
 395   FrameHostMsg_DidCommitProvisionalLoad_Params params(input_params);
 396   FrameTree* frame_tree = render_frame_host->frame_tree_node()->frame_tree();
 397   RenderViewHostImpl* rvh = render_frame_host->render_view_host();
 398   bool use_site_per_process =
 399       CommandLine::ForCurrentProcess()->HasSwitch(switches::kSitePerProcess);
 400
 401   // When using --site-per-process, look up the FrameTreeNode ID that the
 402   // renderer-specific frame ID corresponds to.
 403   int64 frame_tree_node_id = frame_tree->root()->frame_tree_node_id();
 404   if (use_site_per_process) {
 405     frame_tree_node_id =
 406         render_frame_host->frame_tree_node()->frame_tree_node_id();
 407
 408     // TODO(creis): In the short term, cross-process subframe navigations are
 409     // happening in the pending RenderViewHost's top-level frame.  (We need to
 410     // both mirror the frame tree and get the navigation to occur in the correct
 411     // subframe to fix this.)  Until then, we should check whether we have a
 412     // pending NavigationEntry with a frame ID and if so, treat the
 413     // cross-process "main frame" navigation as a subframe navigation.  This
 414     // limits us to a single cross-process subframe per RVH, and it affects
 415     // NavigateToEntry, NavigatorImpl::DidStartProvisionalLoad, and
 416     // OnDidFinishLoad.
 417     NavigationEntryImpl* pending_entry =
 418         NavigationEntryImpl::FromNavigationEntry(
 419             controller_->GetPendingEntry());
 420     int root_ftn_id = frame_tree->root()->frame_tree_node_id();
 421     if (pending_entry &&
 422         pending_entry->frame_tree_node_id() != -1 &&
 423         pending_entry->frame_tree_node_id() != root_ftn_id) {
 424       params.transition = PAGE_TRANSITION_AUTO_SUBFRAME;
 425       frame_tree_node_id = pending_entry->frame_tree_node_id();
 426     }
 427   }
 428
 429   if (PageTransitionIsMainFrame(params.transition)) {
 430     // When overscroll navigation gesture is enabled, a screenshot of the page
 431     // in its current state is taken so that it can be used during the
 432     // nav-gesture. It is necessary to take the screenshot here, before calling
 433     // RenderFrameHostManager::DidNavigateMainFrame, because that can change
 434     // WebContents::GetRenderViewHost to return the new host, instead of the one
 435     // that may have just been swapped out.
 436     if (delegate_ && delegate_->CanOverscrollContent())
 437       controller_->TakeScreenshot();
 438
 439     if (!use_site_per_process)
 440       frame_tree->root()->render_manager()->DidNavigateMainFrame(rvh);
 441   }
 442
 443   // When using --site-per-process, we notify the RFHM for all navigations,
 444   // not just main frame navigations.
 445   if (use_site_per_process) {
 446     FrameTreeNode* frame = frame_tree->FindByID(frame_tree_node_id);
 447     // TODO(creis): Rename to DidNavigateFrame.
 448     frame->render_manager()->DidNavigateMainFrame(rvh);
 449   }
 450
 451   // Update the site of the SiteInstance if it doesn't have one yet, unless
 452   // assigning a site is not necessary for this URL.  In that case, the
 453   // SiteInstance can still be considered unused until a navigation to a real
 454   // page.
 455   SiteInstanceImpl* site_instance =
 456       static_cast<SiteInstanceImpl*>(render_frame_host->GetSiteInstance());
 457   if (!site_instance->HasSite() &&
 458       ShouldAssignSiteForURL(params.url)) {
 459     site_instance->SetSite(params.url);
 460   }
 461
 462   // Need to update MIME type here because it's referred to in
 463   // UpdateNavigationCommands() called by RendererDidNavigate() to
 464   // determine whether or not to enable the encoding menu.
 465   // It's updated only for the main frame. For a subframe,
 466   // RenderView::UpdateURL does not set params.contents_mime_type.
 467   // (see http://code.google.com/p/chromium/issues/detail?id=2929 )
 468   // TODO(jungshik): Add a test for the encoding menu to avoid
 469   // regressing it again.
 470   // TODO(nasko): Verify the correctness of the above comment, since some of the
 471   // code doesn't exist anymore. Also, move this code in the
 472   // PageTransitionIsMainFrame code block above.
 473   if (PageTransitionIsMainFrame(params.transition) && delegate_)
 474     delegate_->SetMainFrameMimeType(params.contents_mime_type);
 475
 476   LoadCommittedDetails details;
 477   bool did_navigate = controller_->RendererDidNavigate(render_frame_host,
 478                                                        params, &details);
 479
 480   // For now, keep track of each frame's URL in its FrameTreeNode.  This lets
 481   // us estimate our process count for implementing OOP iframes.
 482   // TODO(creis): Remove this when we track which pages commit in each frame.
 483   render_frame_host->frame_tree_node()->set_current_url(params.url);
 484
 485   // Send notification about committed provisional loads. This notification is
 486   // different from the NAV_ENTRY_COMMITTED notification which doesn't include
 487   // the actual URL navigated to and isn't sent for AUTO_SUBFRAME navigations.
 488   if (details.type != NAVIGATION_TYPE_NAV_IGNORE && delegate_) {
 489     // For AUTO_SUBFRAME navigations, an event for the main frame is generated
 490     // that is not recorded in the navigation history. For the purpose of
 491     // tracking navigation events, we treat this event as a sub frame navigation
 492     // event.
 493     bool is_main_frame = did_navigate ? details.is_main_frame : false;
 494     PageTransition transition_type = params.transition;
 495     // Whether or not a page transition was triggered by going backward or
 496     // forward in the history is only stored in the navigation controller's
 497     // entry list.
 498     if (did_navigate &&
 499         (controller_->GetLastCommittedEntry()->GetTransitionType() &
 500             PAGE_TRANSITION_FORWARD_BACK)) {
 501       transition_type = PageTransitionFromInt(
 502           params.transition | PAGE_TRANSITION_FORWARD_BACK);
 503     }
 504
 505     delegate_->DidCommitProvisionalLoad(render_frame_host,
 506                                         params.frame_unique_name,
 507                                         is_main_frame,
 508                                         params.url,
 509                                         transition_type);
 510   }
 511
 512   if (!did_navigate)
 513     return;  // No navigation happened.
 514
 515   // DO NOT ADD MORE STUFF TO THIS FUNCTION! Your component should either listen
 516   // for the appropriate notification (best) or you can add it to
 517   // DidNavigateMainFramePostCommit / DidNavigateAnyFramePostCommit (only if
 518   // necessary, please).
 519
 520   // Run post-commit tasks.
 521   if (delegate_) {
 522     if (details.is_main_frame)
 523       delegate_->DidNavigateMainFramePostCommit(details, params);
 524
 525     delegate_->DidNavigateAnyFramePostCommit(
 526         render_frame_host, details, params);
 527   }
 528 }
 529
 530 bool NavigatorImpl::ShouldAssignSiteForURL(const GURL& url) {
 531   // about:blank should not "use up" a new SiteInstance.  The SiteInstance can
 532   // still be used for a normal web site.
 533   if (url == GURL(kAboutBlankURL))
 534     return false;
 535
 536   // The embedder will then have the opportunity to determine if the URL
 537   // should "use up" the SiteInstance.
 538   return GetContentClient()->browser()->ShouldAssignSiteForURL(url);
 539 }
 540
 541 void NavigatorImpl::RequestOpenURL(
 542     RenderFrameHostImpl* render_frame_host,
 543     const GURL& url,
 544     const Referrer& referrer,
 545     WindowOpenDisposition disposition,
 546     int64 source_frame_id,
 547     bool should_replace_current_entry,
 548     bool user_gesture) {
 549   SiteInstance* current_site_instance =
 550       GetRenderManager(render_frame_host)->current_frame_host()->
 551           GetSiteInstance();
 552   // If this came from a swapped out RenderViewHost, we only allow the request
 553   // if we are still in the same BrowsingInstance.
 554   if (render_frame_host->render_view_host()->IsSwappedOut() &&
 555       !render_frame_host->GetSiteInstance()->IsRelatedSiteInstance(
 556           current_site_instance)) {
 557     return;
 558   }
 559
 560   // Delegate to RequestTransferURL because this is just the generic
 561   // case where |old_request_id| is empty.
 562   // TODO(creis): Pass the redirect_chain into this method to support client
 563   // redirects.  http://crbug.com/311721.
 564   std::vector<GURL> redirect_chain;
 565   RequestTransferURL(
 566       render_frame_host, url, redirect_chain, referrer, PAGE_TRANSITION_LINK,
 567       disposition, source_frame_id, GlobalRequestID(),
 568       should_replace_current_entry, user_gesture);
 569 }
 570
 571 void NavigatorImpl::RequestTransferURL(
 572     RenderFrameHostImpl* render_frame_host,
 573     const GURL& url,
 574     const std::vector<GURL>& redirect_chain,
 575     const Referrer& referrer,
 576     PageTransition page_transition,
 577     WindowOpenDisposition disposition,
 578     int64 source_frame_id,
 579     const GlobalRequestID& transferred_global_request_id,
 580     bool should_replace_current_entry,
 581     bool user_gesture) {
 582   GURL dest_url(url);
 583   SiteInstance* current_site_instance =
 584       GetRenderManager(render_frame_host)->current_frame_host()->
 585           GetSiteInstance();
 586   if (!GetContentClient()->browser()->ShouldAllowOpenURL(
 587           current_site_instance, url)) {
 588     dest_url = GURL(kAboutBlankURL);
 589   }
 590
 591   // Look up the FrameTreeNode ID corresponding to source_frame_id.
 592   int64 frame_tree_node_id = -1;
 593   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kSitePerProcess) &&
 594       source_frame_id != -1) {
 595     FrameTreeNode* source_node =
 596         render_frame_host->frame_tree_node()->frame_tree()->FindByRoutingID(
 597             source_frame_id, transferred_global_request_id.child_id);
 598     if (source_node)
 599       frame_tree_node_id = source_node->frame_tree_node_id();
 600   }
 601   OpenURLParams params(
 602       dest_url, referrer, source_frame_id, frame_tree_node_id, disposition,
 603       page_transition, true /* is_renderer_initiated */);
 604   if (redirect_chain.size() > 0)
 605     params.redirect_chain = redirect_chain;
 606   params.transferred_global_request_id = transferred_global_request_id;
 607   params.should_replace_current_entry = should_replace_current_entry;
 608   params.user_gesture = user_gesture;
 609
 610   if (GetRenderManager(render_frame_host)->web_ui()) {
 611     // Web UI pages sometimes want to override the page transition type for
 612     // link clicks (e.g., so the new tab page can specify AUTO_BOOKMARK for
 613     // automatically generated suggestions).  We don't override other types
 614     // like TYPED because they have different implications (e.g., autocomplete).
 615     if (PageTransitionCoreTypeIs(params.transition, PAGE_TRANSITION_LINK))
 616       params.transition =
 617           GetRenderManager(render_frame_host)->web_ui()->
 618               GetLinkTransitionType();
 619
 620     // Note also that we hide the referrer for Web UI pages. We don't really
 621     // want web sites to see a referrer of "chrome://blah" (and some
 622     // chrome: URLs might have search terms or other stuff we don't want to
 623     // send to the site), so we send no referrer.
 624     params.referrer = Referrer();
 625
 626     // Navigations in Web UI pages count as browser-initiated navigations.
 627     params.is_renderer_initiated = false;
 628   }
 629
 630   if (delegate_)
 631     delegate_->RequestOpenURL(params);
 632 }
 633
 634 }  // namespace content