Move ExtraData from WebRequest to WebDataSource....

chrome/renderer/render_view.cc

 // Copyright (c) 2009 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/renderer/render_view.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 122 matching lines @@
 static int32 next_page_id_ = 1;
 
 // The maximum number of popups that can be spawned from one page.
 static const int kMaximumNumberOfUnacknowledgedPopups = 25;
 
 static const char* const kUnreachableWebDataURL =
     "chrome://chromewebdata/";
 
 static const char* const kBackForwardNavigationScheme = "history";
 
-namespace {
-
 // Associated with browser-initiated navigations to hold tracking data.
-class RenderViewExtraRequestData : public WebRequest::ExtraData {
+class RenderView::NavigationState : public WebDataSource::ExtraData {
  public:
-  RenderViewExtraRequestData(int32 pending_page_id,
-                             PageTransition::Type transition,
-                             Time request_time)
+  NavigationState(int32 pending_page_id,
+                  PageTransition::Type transition,
+                  Time request_time)
       : transition_type(transition),
         request_time(request_time),
         request_committed(false),
         pending_page_id_(pending_page_id) {
   }
 
   // Contains the page_id for this navigation or -1 if there is none yet.
   int32 pending_page_id() const { return pending_page_id_; }
 
   // Is this a new navigation?
   bool is_new_navigation() const { return pending_page_id_ == -1; }
 
   // Contains the transition type that the browser specified when it
   // initiated the load.
   PageTransition::Type transition_type;
+
+  // The time that this navigation was requested.
   Time request_time;
 
   // True if we have already processed the "DidCommitLoad" event for this
   // request.  Used by session history.
   bool request_committed;
 
  private:
   int32 pending_page_id_;
 
-  DISALLOW_COPY_AND_ASSIGN(RenderViewExtraRequestData);
+  DISALLOW_COPY_AND_ASSIGN(NavigationState);
 };
 
-}  // namespace
-
 ///////////////////////////////////////////////////////////////////////////////
 
 RenderView::RenderView(RenderThreadBase* render_thread)
     : RenderWidget(render_thread, true),
       enabled_bindings_(0),
       target_url_status_(TARGET_NONE),
       is_loading_(false),
       navigation_gesture_(NavigationGestureUnknown),
       page_id_(-1),
       last_page_id_sent_to_browser_(-1),
@@ skipping 610 matching lines @@
   if (is_reload) {
     cache_policy = WebRequestReloadIgnoringCacheData;
   } else if (params.page_id != -1 || main_frame->GetInViewSourceMode()) {
     cache_policy = WebRequestReturnCacheDataElseLoad;
   } else {
     cache_policy = WebRequestUseProtocolCachePolicy;
   }
 
   scoped_ptr<WebRequest> request(WebRequest::Create(params.url));
   request->SetCachePolicy(cache_policy);
-  request->SetExtraData(new RenderViewExtraRequestData(
-      params.page_id, params.transition, params.request_time));
+
+  // A navigation resulting from loading a javascript URL should not be treated
+  // as a browser initiated event.  Instead, we want it to look as if the page
+  // initiated any load resulting from JS execution.
+  if (!params.url.SchemeIs(chrome::kJavaScriptScheme)) {
+    pending_navigation_state_.reset(new NavigationState(
+        params.page_id, params.transition, params.request_time));
+  }
 
   // If we are reloading, then WebKit will use the state of the current page.
   // Otherwise, we give it the state to navigate to.
   if (!is_reload)
     request->SetHistoryState(params.state);
 
   if (params.referrer.is_valid()) {
     request->SetHttpHeaderValue("Referer",
                                 params.referrer.spec());
   }
 
   main_frame->LoadRequest(request.get());
+
+  // In case LoadRequest failed before DidCreateDataSource was called.
+  pending_navigation_state_.reset();
 }
 
 // Stop loading the current page
 void RenderView::OnStop() {
   if (webview())
     webview()->StopLoading();
 }
 
 void RenderView::OnLoadAlternateHTMLText(const std::string& html_contents,
                                          bool new_navigation,
@@ skipping 136 matching lines @@
 
 // Tell the embedding application that the URL of the active page has changed
 void RenderView::UpdateURL(WebFrame* frame) {
   WebDataSource* ds = frame->GetDataSource();
   DCHECK(ds);
 
   const WebRequest& request = ds->GetRequest();
   const WebRequest& initial_request = ds->GetInitialRequest();
   const WebResponse& response = ds->GetResponse();
 
-  // We don't hold a reference to the extra data. The request's reference will
-  // be sufficient because we won't modify it during our call. MAY BE NULL.
-  RenderViewExtraRequestData* extra_data =
-      static_cast<RenderViewExtraRequestData*>(request.GetExtraData());
+  // This will be null if we did not initiate the navigation.
+  NavigationState* navigation_state =
+      static_cast<NavigationState*>(ds->GetExtraData());
 
   ViewHostMsg_FrameNavigate_Params params;
   params.http_status_code = response.GetHttpStatusCode();
   params.is_post = false;
   params.page_id = page_id_;
   params.is_content_filtered = response.IsContentFiltered();
   if (!request.GetSecurityInfo().empty()) {
     // SSL state specified in the request takes precedence over the one in the
     // response.
     // So far this is only intended for error pages that are not expected to be
@@ skipping 23 matching lines @@
   }
 
   const PasswordForm* password_form_data =
       frame->GetDataSource()->GetPasswordFormData();
   if (password_form_data)
     params.password_form = *password_form_data;
 
   params.gesture = navigation_gesture_;
   navigation_gesture_ = NavigationGestureUnknown;
 
-  if (webview()->GetMainFrame() == frame) {
+  if (!frame->GetParent()) {

[brettw, 2009/05/20 23:41:04]

This is another place you changed the parent thing.

[darin (slow to review), 2009/05/21 00:06:02]

Yeah... cross your fingers for me!

     // Top-level navigation.
 
     // Update contents MIME type for main frame.
     params.contents_mime_type = ds->GetResponse().GetMimeType();
 
     // We assume top level navigations initiated by the renderer are link
     // clicks.
-    params.transition = extra_data ?
-        extra_data->transition_type : PageTransition::LINK;
+    params.transition = navigation_state ?
+        navigation_state->transition_type : PageTransition::LINK;
     if (!PageTransition::IsMainFrame(params.transition)) {
       // If the main frame does a load, it should not be reported as a subframe
       // navigation.  This can occur in the following case:
       // 1. You're on a site with frames.
       // 2. You do a subframe navigation.  This is stored with transition type
       //    MANUAL_SUBFRAME.
       // 3. You navigate to some non-frame site, say, google.com.
       // 4. You navigate back to the page from step 2.  Since it was initially
       //    MANUAL_SUBFRAME, it will be that same transition type here.
       // We don't want that, because any navigation that changes the toplevel
@@ skipping 30 matching lines @@
     // Subframe navigation: the type depends on whether this navigation
     // generated a new session history entry. When they do generate a session
     // history entry, it means the user initiated the navigation and we should
     // mark it as such. This test checks if this is the first time UpdateURL
     // has been called since WillNavigateToURL was called to initiate the load.
     if (page_id_ > last_page_id_sent_to_browser_)
       params.transition = PageTransition::MANUAL_SUBFRAME;
     else
       params.transition = PageTransition::AUTO_SUBFRAME;
 
-    // The browser should never initiate a subframe navigation.
-    DCHECK(!extra_data);
     Send(new ViewHostMsg_FrameNavigate(routing_id_, params));
   }
 
   last_page_id_sent_to_browser_ =
       std::max(last_page_id_sent_to_browser_, page_id_);
 
   // If we end up reusing this WebRequest (for example, due to a #ref click),
   // we don't want the transition type to persist.
-  if (extra_data)
-    extra_data->transition_type = PageTransition::LINK;  // Just clear it.
+  if (navigation_state)
+    navigation_state->transition_type = PageTransition::LINK;  // Just clear it.
 
 #if defined(OS_WIN)
   if (web_accessibility_manager_.get()) {
     // Clear accessibility info cache.
     web_accessibility_manager_->ClearAccObjMap(-1, true);
   }
 #else
   // TODO(port): accessibility not yet implemented. See http://crbug.com/8288.
 #endif
 }
@@ skipping 78 matching lines @@
       kDelayForCaptureMs);
 
   // The page is loaded. Try to process the file we need to upload if any.
   ProcessPendingUpload();
 
   // Since the page is done loading, we are sure we don't need to try
   // again.
   ResetPendingUpload();
 }
 
+void RenderView::DidCreateDataSource(WebFrame* frame, WebDataSource* ds) {
+  ds->SetExtraData(pending_navigation_state_.release());
+}
+
 void RenderView::DidStartProvisionalLoadForFrame(
     WebView* webview,
     WebFrame* frame,
     NavigationGesture gesture) {
   if (webview->GetMainFrame() == frame) {
     navigation_gesture_ = gesture;
 
     // Make sure redirect tracking state is clear for the new load.
     completed_client_redirect_src_ = GURL();
   }
 
   WebDataSource* ds = frame->GetProvisionalDataSource();
   if (ds) {
-    const WebRequest& req = ds->GetRequest();
-    RenderViewExtraRequestData* extra_data =
-        static_cast<RenderViewExtraRequestData*>(req.GetExtraData());
-    if (extra_data) {
-      ds->SetRequestTime(extra_data->request_time);
-    }
+    NavigationState* navigation_state =
+        static_cast<NavigationState*>(ds->GetExtraData());
+    if (navigation_state)
+      ds->SetRequestTime(navigation_state->request_time);
   }
   Send(new ViewHostMsg_DidStartProvisionalLoadForFrame(
        routing_id_, webview->GetMainFrame() == frame,
        frame->GetProvisionalDataSource()->GetRequest().GetURL()));
 }
 
 bool RenderView::DidLoadResourceFromMemoryCache(WebView* webview,
                                                 const WebRequest& request,
                                                 const WebResponse& response,
                                                 WebFrame* frame) {
@@ skipping 51 matching lines @@
 
   // Don't display an error page if this is simply a cancelled load.  Aside
   // from being dumb, WebCore doesn't expect it and it will cause a crash.
   if (error.GetErrorCode() == net::ERR_ABORTED)
     return;
 
   // If this is a failed back/forward/reload navigation, then we need to do a
   // 'replace' load.  This is necessary to avoid messing up session history.
   // Otherwise, we do a normal load, which simulates a 'go' navigation as far
   // as session history is concerned.
-  RenderViewExtraRequestData* extra_data =
-      static_cast<RenderViewExtraRequestData*>(failed_request.GetExtraData());
-  bool replace = extra_data && !extra_data->is_new_navigation();
+  NavigationState* navigation_state =
+      static_cast<NavigationState*>(ds->GetExtraData());
+  bool replace = navigation_state && !navigation_state->is_new_navigation();
 
   // Use the alternate error page service if this is a DNS failure or
   // connection failure.  ERR_CONNECTION_FAILED can be dropped once we no longer
   // use winhttp.
   int ec = error.GetErrorCode();
   if (ec == net::ERR_NAME_NOT_RESOLVED ||
       ec == net::ERR_CONNECTION_FAILED ||
       ec == net::ERR_CONNECTION_REFUSED ||
       ec == net::ERR_ADDRESS_UNREACHABLE ||
       ec == net::ERR_TIMED_OUT) {
@@ skipping 46 matching lines @@
   // Use a data: URL as the site URL to prevent against XSS attacks.
   scoped_ptr<WebRequest> request(failed_request->Clone());
   request->SetURL(GURL(kUnreachableWebDataURL));
 
   frame->LoadAlternateHTMLString(request.get(), alt_html, failed_url,
       replace);
 }
 
 void RenderView::DidCommitLoadForFrame(WebView *webview, WebFrame* frame,
                                        bool is_new_navigation) {
-  const WebRequest& request =
-      webview->GetMainFrame()->GetDataSource()->GetRequest();
-  RenderViewExtraRequestData* extra_data =
-      static_cast<RenderViewExtraRequestData*>(request.GetExtraData());
+  NavigationState* navigation_state = static_cast<NavigationState*>(
+      frame->GetDataSource()->GetExtraData());
 
   if (is_new_navigation) {
     // When we perform a new navigation, we need to update the previous session
     // history entry with state for the page we are leaving.
     UpdateSessionHistory(frame);
 
     // We bump our Page ID to correspond with the new session history entry.
     page_id_ = next_page_id_++;
 
     MessageLoop::current()->PostDelayedTask(FROM_HERE,
         method_factory_.NewRunnableMethod(&RenderView::CapturePageInfo,
                                           page_id_, true),
         kDelayForForcedCaptureMs);
   } else {
-    // Inspect the extra_data on the main frame (set in our Navigate method) to
-    // see if the navigation corresponds to a session history navigation...
-    // Note: |frame| may or may not be the toplevel frame, but for the case
-    // of capturing session history, the first committed frame suffices.  We
-    // keep track of whether we've seen this commit before so that only capture
-    // session history once per navigation.
+    // Inspect the navigation_state on the main frame (set in our Navigate
+    // method) to see if the navigation corresponds to a session history
+    // navigation...  Note: |frame| may or may not be the toplevel frame, but
+    // for the case of capturing session history, the first committed frame
+    // suffices.  We keep track of whether we've seen this commit before so
+    // that only capture session history once per navigation.
     //
     // Note that we need to check if the page ID changed. In the case of a
     // reload, the page ID doesn't change, and UpdateSessionHistory gets the
     // previous URL and the current page ID, which would be wrong.
-    if (extra_data && !extra_data->is_new_navigation() &&
-        !extra_data->request_committed &&
-        page_id_ != extra_data->pending_page_id()) {
+    if (navigation_state && !navigation_state->is_new_navigation() &&
+        !navigation_state->request_committed &&
+        page_id_ != navigation_state->pending_page_id()) {
       // This is a successful session history navigation!
       UpdateSessionHistory(frame);
-      page_id_ = extra_data->pending_page_id();
+      page_id_ = navigation_state->pending_page_id();
     }
   }
 
   // Remember that we've already processed this request, so we don't update
   // the session history again.  We do this regardless of whether this is
   // a session history navigation, because if we attempted a session history
   // navigation without valid HistoryItem state, WebCore will think it is a
   // new navigation.
-  if (extra_data)
-    extra_data->request_committed = true;
+  if (navigation_state)
+    navigation_state->request_committed = true;
 
   UpdateURL(frame);
 
   // If this committed load was initiated by a client redirect, we're
   // at the last stop now, so clear it.
   completed_client_redirect_src_ = GURL();
 
   // Check whether we have new encoding name.
   UpdateEncoding(frame, webview->GetMainFrameEncodingName());
 }
@@ skipping 30 matching lines @@
         frame, UserScript::DOCUMENT_END);
 }
 
 void RenderView::DidHandleOnloadEventsForFrame(WebView* webview,
                                                WebFrame* frame) {
 }
 
 void RenderView::DidChangeLocationWithinPageForFrame(WebView* webview,
                                                      WebFrame* frame,
                                                      bool is_new_navigation) {
+  // If this was a reference fragment navigation that we initiated, then we
+  // could end up having a non-null pending navigation state.  We just need to
+  // update the ExtraData on the datasource so that others who read the
+  // ExtraData will get the new NavigationState.  Similarly, if we did not
+  // initiate this navigation, then we need to take care to clear any pre-
+  // existing navigation state.
+  frame->GetDataSource()->SetExtraData(pending_navigation_state_.release());
+
   DidCommitLoadForFrame(webview, frame, is_new_navigation);
+
   const string16& title =
       webview->GetMainFrame()->GetDataSource()->GetPageTitle();
   UpdateTitle(frame, UTF16ToWideHack(title));
 }
 
 void RenderView::DidReceiveIconForFrame(WebView* webview,
                                         WebFrame* frame) {
 }
 
 void RenderView::WillPerformClientRedirect(WebView* webview,
@@ skipping 82 matching lines @@
         frame, UserScript::DOCUMENT_START);
 }
 
 WindowOpenDisposition RenderView::DispositionForNavigationAction(
     WebView* webview,
     WebFrame* frame,
     const WebRequest* request,
     WebNavigationType type,
     WindowOpenDisposition disposition,
     bool is_redirect) {
+  // GetExtraData is NULL when we did not issue the request ourselves (see
+  // OnNavigate), and so such a request may correspond to a link-click,
+  // script, or drag-n-drop initiated navigation.
+  bool is_content_initiated =
+      !frame->GetProvisionalDataSource()->GetExtraData();
+
   // Webkit is asking whether to navigate to a new URL.
   // This is fine normally, except if we're showing UI from one security
   // context and they're trying to navigate to a different context.
   const GURL& url = request->GetURL();
+
   // We only care about navigations that are within the current tab (as opposed
   // to, for example, opening a new window).
   // But we sometimes navigate to about:blank to clear a tab, and we want to
   // still allow that.
-  if (disposition == CURRENT_TAB && !(url.SchemeIs(chrome::kAboutScheme))) {
-    // GetExtraData is NULL when we did not issue the request ourselves (see
-    // OnNavigate), and so such a request may correspond to a link-click,
-    // script, or drag-n-drop initiated navigation.
-    if (frame == webview->GetMainFrame() && !request->GetExtraData()) {
-      // When we received such unsolicited navigations, we sometimes want to
-      // punt them up to the browser to handle.
-      if (BindingsPolicy::is_dom_ui_enabled(enabled_bindings_) ||
-          frame->GetInViewSourceMode() ||
-          url.SchemeIs(chrome::kViewSourceScheme)) {
-        OpenURL(webview, url, GURL(), disposition);
-        return IGNORE_ACTION;  // Suppress the load here.
-      }
+  if (disposition == CURRENT_TAB && is_content_initiated &&
+      frame->GetParent() == NULL && !url.SchemeIs(chrome::kAboutScheme)) {
+    // When we received such unsolicited navigations, we sometimes want to
+    // punt them up to the browser to handle.
+    if (BindingsPolicy::is_dom_ui_enabled(enabled_bindings_) ||
+        frame->GetInViewSourceMode() ||
+        url.SchemeIs(chrome::kViewSourceScheme)) {
+      OpenURL(webview, url, GURL(), disposition);
+      return IGNORE_ACTION;  // Suppress the load here.
     }
   }
 
   // Detect when a page is "forking" a new tab that can be safely rendered in
   // its own process.  This is done by sites like Gmail that try to open links
   // in new windows without script connections back to the original page.  We
   // treat such cases as browser navigations (in which we will create a new
   // renderer for a cross-site navigation), rather than WebKit navigations.
   //
   // We use the following heuristic to decide whether to fork a new page in its
   // own process:
   // The parent page must open a new tab to about:blank, set the new tab's
   // window.opener to null, and then redirect the tab to a cross-site URL using
   // JavaScript.
   bool is_fork =
       // Must start from a tab showing about:blank, which is later redirected.
       frame->GetURL() == GURL("about:blank") &&
       // Must be the first real navigation of the tab.
       GetHistoryBackListCount() < 1 &&
       GetHistoryForwardListCount() < 1 &&
       // The parent page must have set the child's window.opener to null before
       // redirecting to the desired URL.
       frame->GetOpener() == NULL &&
       // Must be a top-level frame.
       frame->GetParent() == NULL &&
-      // Must not have issued the request from this page.  GetExtraData is NULL
-      // when the navigation is being done by something outside the page.
-      !request->GetExtraData() &&
+      // Must not have issued the request from this page.
+      is_content_initiated &&
       // Must be targeted at the current tab.
       disposition == CURRENT_TAB &&
       // Must be a JavaScript navigation, which appears as "other".
       type == WebNavigationTypeOther;
   if (is_fork) {
     // Open the URL via the browser, not via WebKit.
     OpenURL(webview, url, GURL(), disposition);
     return IGNORE_ACTION;
   }
 
@@ skipping 1243 matching lines @@
 
 void RenderView::DidAddHistoryItem() {
   // We don't want to update the history length for the start page
   // navigation.
   WebFrame* main_frame = webview()->GetMainFrame();
   DCHECK(main_frame != NULL);
 
   WebDataSource* ds = main_frame->GetDataSource();
   DCHECK(ds != NULL);
 
-  const WebRequest& request = ds->GetRequest();
-  RenderViewExtraRequestData* extra_data =
-      static_cast<RenderViewExtraRequestData*>(request.GetExtraData());
+  NavigationState* navigation_state =
+      static_cast<NavigationState*>(ds->GetExtraData());
 
-  if (extra_data && extra_data->transition_type == PageTransition::START_PAGE)
+  if (navigation_state &&
+      navigation_state->transition_type == PageTransition::START_PAGE)
     return;
 
   history_back_list_count_++;
   history_forward_list_count_ = 0;
 }
 
 void RenderView::OnMessageFromExternalHost(const std::string& message,
                                            const std::string& origin,
                                            const std::string& target) {
   if (message.empty())
@@ skipping 137 matching lines @@
     }
   }
   UMA_HISTOGRAM_TIMES("Renderer.All.StartToFinishDoc", start_to_finish_doc);
   UMA_HISTOGRAM_TIMES("Renderer.All.FinishDocToFinish", finish_doc_to_finish);
   UMA_HISTOGRAM_TIMES("Renderer.All.StartToFinish", start_to_finish);
   if (start_to_first_layout.ToInternalValue() >= 0) {
     UMA_HISTOGRAM_TIMES(
       "Renderer.All.StartToFirstLayout", start_to_first_layout);
   }
 }