Remove a bunch of provisionalDataSource() usage.

content/renderer/render_frame_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/renderer/render_frame_impl.h"
 
 #include <map>
 #include <string>
 
 #include "base/auto_reset.h"
@@ skipping 2442 matching lines @@
   return render_view_->history_controller()->GetItemForNewChildFrame(this);
 }
 
 void RenderFrameImpl::willSendSubmitEvent(blink::WebLocalFrame* frame,
                                           const blink::WebFormElement& form) {
   DCHECK(!frame_ || frame_ == frame);
 
   FOR_EACH_OBSERVER(RenderFrameObserver, observers_, WillSendSubmitEvent(form));
 }
 
-void RenderFrameImpl::willSubmitForm(blink::WebLocalFrame* frame,
+void RenderFrameImpl::willSubmitForm(blink::WebDataSource* datasource,
                                      const blink::WebFormElement& form) {
-  DCHECK(!frame_ || frame_ == frame);
-  DocumentState* document_state =
-      DocumentState::FromDataSource(frame->provisionalDataSource());
+  DocumentState* document_state = DocumentState::FromDataSource(datasource);
   NavigationStateImpl* navigation_state =
       static_cast<NavigationStateImpl*>(document_state->navigation_state());
   InternalDocumentStateData* internal_data =
       InternalDocumentStateData::FromDocumentState(document_state);
 
   if (ui::PageTransitionCoreTypeIs(navigation_state->GetTransitionType(),
                                    ui::PAGE_TRANSITION_LINK)) {
     navigation_state->set_transition_type(ui::PAGE_TRANSITION_FORM_SUBMIT);
   }
 
@@ skipping 115 matching lines @@
       provider_type = SERVICE_WORKER_PROVIDER_FOR_SANDBOXED_FRAME;
     }
     scoped_ptr<ServiceWorkerNetworkProvider> network_provider(
         new ServiceWorkerNetworkProvider(routing_id_, provider_type));
     ServiceWorkerNetworkProvider::AttachToDocumentState(
         DocumentState::FromDataSource(datasource),
         network_provider.Pass());
   }
 }
 
-void RenderFrameImpl::didStartProvisionalLoad(blink::WebLocalFrame* frame,
+void RenderFrameImpl::didStartProvisionalLoad(blink::WebDataSource* datasource,
                                               double triggering_event_time) {
-  DCHECK(!frame_ || frame_ == frame);
-  WebDataSource* ds = frame->provisionalDataSource();
+  DCHECK(datasource);
 
-  // In fast/loader/stop-provisional-loads.html, we abort the load before this
-  // callback is invoked.
-  if (!ds)
-    return;
-
-  TRACE_EVENT2("navigation", "RenderFrameImpl::didStartProvisionalLoad",
-               "id", routing_id_, "url", ds->request().url().string().utf8());
-  DocumentState* document_state = DocumentState::FromDataSource(ds);
+  TRACE_EVENT2("navigation", "RenderFrameImpl::didStartProvisionalLoad", "id",
+               routing_id_, "url", datasource->request().url().string().utf8());
+  DocumentState* document_state = DocumentState::FromDataSource(datasource);
 
   // We should only navigate to swappedout:// when is_swapped_out_ is true.
-  CHECK_IMPLIES(ds->request().url() == GURL(kSwappedOutURL), is_swapped_out_)
+  CHECK_IMPLIES(datasource->request().url() == GURL(kSwappedOutURL),
+                is_swapped_out_)
       << "Heard swappedout:// when not swapped out.";
 
   // Update the request time if WebKit has better knowledge of it.
   if (document_state->request_time().is_null() &&
           triggering_event_time != 0.0) {
     document_state->set_request_time(Time::FromDoubleT(triggering_event_time));
   }
 
   // Start time is only set after request time.
   document_state->set_start_load_time(Time::Now());
 
-  bool is_top_most = !frame->parent();
+  bool is_top_most = !frame_->parent();
   if (is_top_most) {
     render_view_->set_navigation_gesture(
         WebUserGestureIndicator::isProcessingUserGesture() ?
             NavigationGestureUser : NavigationGestureAuto);
-  } else if (ds->replacesCurrentHistoryItem()) {
+  } else if (datasource->replacesCurrentHistoryItem()) {
     // Subframe navigations that don't add session history items must be
     // marked with AUTO_SUBFRAME. See also didFailProvisionalLoad for how we
     // handle loading of error pages.
     static_cast<NavigationStateImpl*>(document_state->navigation_state())
         ->set_transition_type(ui::PAGE_TRANSITION_AUTO_SUBFRAME);
   }
 
   FOR_EACH_OBSERVER(RenderViewObserver, render_view_->observers(),
-                    DidStartProvisionalLoad(frame));
-  FOR_EACH_OBSERVER(RenderFrameObserver, observers_, DidStartProvisionalLoad());
+                    DidStartProvisionalLoad(datasource));
+  FOR_EACH_OBSERVER(RenderFrameObserver, observers_,
+                    DidStartProvisionalLoad(datasource));
 
   Send(new FrameHostMsg_DidStartProvisionalLoadForFrame(
-       routing_id_, ds->request().url()));
+      routing_id_, datasource->request().url()));
 }
 
 void RenderFrameImpl::didReceiveServerRedirectForProvisionalLoad(
     blink::WebLocalFrame* frame) {
   DCHECK(!frame_ || frame_ == frame);
   render_view_->history_controller()->RemoveChildrenForRedirect(this);
 }
 
 void RenderFrameImpl::didFailProvisionalLoad(
-    blink::WebLocalFrame* frame,
+    blink::WebDataSource* datasource,
     const blink::WebURLError& error,
     blink::WebHistoryCommitType commit_type) {
   TRACE_EVENT1("navigation", "RenderFrameImpl::didFailProvisionalLoad",
                "id", routing_id_);
-  DCHECK(!frame_ || frame_ == frame);
-  WebDataSource* ds = frame->provisionalDataSource();
-  DCHECK(ds);
+  DCHECK(datasource);
 
-  const WebURLRequest& failed_request = ds->request();
+  const WebURLRequest& failed_request = datasource->request();
 
   // Notify the browser that we failed a provisional load with an error.
   //
   // Note: It is important this notification occur before DidStopLoading so the
   //       SSL manager can react to the provisional load failure before being
   //       notified the load stopped.
   //
   FOR_EACH_OBSERVER(RenderViewObserver, render_view_->observers(),
-                    DidFailProvisionalLoad(frame, error));
+                    DidFailProvisionalLoad(frame_, error));
   FOR_EACH_OBSERVER(RenderFrameObserver, observers_,
                     DidFailProvisionalLoad(error));
 
-  SendFailedProvisionalLoad(failed_request, error, frame);
+  SendFailedProvisionalLoad(failed_request, error, frame_);
 
   if (!ShouldDisplayErrorPageForFailedLoad(error.reason, error.unreachableURL))
     return;
 
   // Make sure we never show errors in view source mode.
-  frame->enableViewSourceMode(false);
+  frame_->enableViewSourceMode(false);
 
-  DocumentState* document_state = DocumentState::FromDataSource(ds);
+  DocumentState* document_state = DocumentState::FromDataSource(datasource);
   NavigationStateImpl* navigation_state =
       static_cast<NavigationStateImpl*>(document_state->navigation_state());
 
   // 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.
   bool replace = commit_type != blink::WebStandardCommit;
 
   // If we failed on a browser initiated request, then make sure that our error
@@ skipping 286 matching lines @@
             frame->dataSource()->request().inputPerfMetricReportPolicy());
     base::TimeTicks ui_timestamp = base::TimeTicks() +
         base::TimeDelta::FromSecondsD(
             frame->dataSource()->request().uiStartTime());
 
     Send(new FrameHostMsg_DocumentOnLoadCompleted(
         routing_id_, report_type, ui_timestamp));
   }
 }
 
-void RenderFrameImpl::didFailLoad(blink::WebLocalFrame* frame,
+void RenderFrameImpl::didFailLoad(blink::WebDataSource* datasource,
                                   const blink::WebURLError& error,
                                   blink::WebHistoryCommitType commit_type) {
   TRACE_EVENT1("navigation", "RenderFrameImpl::didFailLoad",
                "id", routing_id_);
-  DCHECK(!frame_ || frame_ == frame);
   // TODO(nasko): Move implementation here. No state needed.
-  WebDataSource* ds = frame->dataSource();
-  DCHECK(ds);
+  DCHECK(datasource);
 
   FOR_EACH_OBSERVER(RenderViewObserver, render_view_->observers(),
-                    DidFailLoad(frame, error));
+                    DidFailLoad(frame_, error));
 
-  const WebURLRequest& failed_request = ds->request();
+  const WebURLRequest& failed_request = datasource->request();
   base::string16 error_description;
   GetContentClient()->renderer()->GetNavigationErrorStrings(
-      render_view_.get(),
-      frame,
-      failed_request,
-      error,
-      NULL,
+      render_view_.get(), frame_, failed_request, error, NULL,
       &error_description);
   Send(new FrameHostMsg_DidFailLoadWithError(routing_id_,
                                              failed_request.url(),
                                              error.reason,
                                              error_description,
                                              error.wasIgnoredByHandler));
 }
 
 void RenderFrameImpl::didFinishLoad(blink::WebLocalFrame* frame) {
   TRACE_EVENT1("navigation", "RenderFrameImpl::didFinishLoad",
@@ skipping 188 matching lines @@
 #endif
 
   Send(new FrameHostMsg_ContextMenu(routing_id_, params));
 }
 
 void RenderFrameImpl::clearContextMenu() {
   context_menu_node_.reset();
 }
 
 void RenderFrameImpl::willSendRequest(
-    blink::WebLocalFrame* frame,
+    blink::WebDataSource* datasource,
     unsigned identifier,
     blink::WebURLRequest& request,
     const blink::WebURLResponse& redirect_response) {
-  DCHECK(!frame_ || frame_ == frame);
+  DCHECK(datasource);
   // The request my be empty during tests.
   if (request.url().isEmpty())
     return;
 
   // Set the first party for cookies url if it has not been set yet (new
   // requests). For redirects, it is updated by WebURLLoaderImpl.
   if (request.firstPartyForCookies().isEmpty()) {
     if (request.frameType() == blink::WebURLRequest::FrameTypeTopLevel) {
       request.setFirstPartyForCookies(request.url());
     } else {
       // TODO(nasko): When the top-level frame is remote, there is no document.
       // This is broken and should be fixed to propagate the first party.
-      WebFrame* top = frame->top();
+      WebFrame* top = frame_->top();
       if (top->isWebLocalFrame()) {
         request.setFirstPartyForCookies(
-            frame->top()->document().firstPartyForCookies());
+            frame_->top()->document().firstPartyForCookies());
       }
     }
   }
 
-  WebDataSource* provisional_data_source = frame->provisionalDataSource();
-  WebDataSource* data_source =
-      provisional_data_source ? provisional_data_source : frame->dataSource();
-
-  DocumentState* document_state = DocumentState::FromDataSource(data_source);
+  DocumentState* document_state = DocumentState::FromDataSource(datasource);
   DCHECK(document_state);
   InternalDocumentStateData* internal_data =
       InternalDocumentStateData::FromDocumentState(document_state);
   NavigationStateImpl* navigation_state =
       static_cast<NavigationStateImpl*>(document_state->navigation_state());
   ui::PageTransition transition_type = navigation_state->GetTransitionType();
-  if (provisional_data_source && provisional_data_source->isClientRedirect()) {
+  if (request.frameType() != blink::WebURLRequest::FrameTypeNone &&
+      datasource->isClientRedirect()) {
     transition_type = ui::PageTransitionFromInt(
         transition_type | ui::PAGE_TRANSITION_CLIENT_REDIRECT);
   }
 
   GURL request_url(request.url());
   GURL new_url;
   if (GetContentClient()->renderer()->WillSendRequest(
-          frame,
-          transition_type,
-          request_url,
-          request.firstPartyForCookies(),
+          frame_, transition_type, request_url, request.firstPartyForCookies(),
           &new_url)) {
     request.setURL(WebURL(new_url));
   }
 
   if (internal_data->is_cache_policy_override_set())
     request.setCachePolicy(internal_data->cache_policy_override());
 
   // The request's extra data may indicate that we should set a custom user
   // agent. This needs to be done here, after WebKit is through with setting the
   // user agent on its own. Similarly, it may indicate that we should set an
@@ skipping 36 matching lines @@
 
   // Add an empty HTTP origin header for non GET methods if none is currently
   // present.
   request.addHTTPOriginIfNeeded(WebString());
 
   // Attach |should_replace_current_entry| state to requests so that, should
   // this navigation later require a request transfer, all state is preserved
   // when it is re-created in the new process.
   bool should_replace_current_entry = false;
   if (navigation_state->IsContentInitiated()) {
-    should_replace_current_entry = data_source->replacesCurrentHistoryItem();
+    should_replace_current_entry = datasource->replacesCurrentHistoryItem();
   } else {
     // If the navigation is browser-initiated, the NavigationState contains the
     // correct value instead of the WebDataSource.
     //
     // TODO(davidben): Avoid this awkward duplication of state. See comment on
     // NavigationState::should_replace_current_entry().
     should_replace_current_entry =
         navigation_state->common_params().should_replace_current_entry;
   }
 
-  int provider_id = kInvalidServiceWorkerProviderId;
-  if (request.frameType() == blink::WebURLRequest::FrameTypeTopLevel ||
-      request.frameType() == blink::WebURLRequest::FrameTypeNested) {
-    // |provisionalDataSource| may be null in some content::ResourceFetcher
-    // use cases, we don't hook those requests.
-    if (frame->provisionalDataSource()) {
-      ServiceWorkerNetworkProvider* provider =
-          ServiceWorkerNetworkProvider::FromDocumentState(
-              DocumentState::FromDataSource(frame->provisionalDataSource()));
-      provider_id = provider->provider_id();
-    }
-  } else if (frame->dataSource()) {
-    ServiceWorkerNetworkProvider* provider =
-        ServiceWorkerNetworkProvider::FromDocumentState(
-            DocumentState::FromDataSource(frame->dataSource()));
-    provider_id = provider->provider_id();
-    // Explicitly set the SkipServiceWorker flag here if the renderer process
-    // hasn't received SetControllerServiceWorker message.
-    if (!provider->IsControlledByServiceWorker())
-      request.setSkipServiceWorker(true);
+  ServiceWorkerNetworkProvider* provider =
+      ServiceWorkerNetworkProvider::FromDocumentState(document_state);
+  int provider_id = provider->provider_id();
+  if (request.frameType() != blink::WebURLRequest::FrameTypeTopLevel &&
+      request.frameType() != blink::WebURLRequest::FrameTypeNested &&
+      !provider->IsControlledByServiceWorker()) {
+    request.setSkipServiceWorker(true);
   }
 
-  WebFrame* parent = frame->parent();
+  WebFrame* parent = frame_->parent();
   int parent_routing_id = MSG_ROUTING_NONE;
   if (!parent) {
     parent_routing_id = -1;
   } else if (parent->isWebLocalFrame()) {
     parent_routing_id = FromWebFrame(parent)->GetRoutingID();
   } else {
     parent_routing_id = RenderFrameProxy::FromWebFrame(parent)->routing_id();
   }
 
   RequestExtraData* extra_data = new RequestExtraData();
   extra_data->set_visibility_state(render_view_->visibilityState());
   extra_data->set_custom_user_agent(custom_user_agent);
   extra_data->set_requested_with(requested_with);
   extra_data->set_render_frame_id(routing_id_);
   extra_data->set_is_main_frame(!parent);
   extra_data->set_frame_origin(
-      GURL(frame->document().securityOrigin().toString()));
+      GURL(frame_->document().securityOrigin().toString()));
   extra_data->set_parent_is_main_frame(parent && !parent->parent());
   extra_data->set_parent_render_frame_id(parent_routing_id);
   extra_data->set_allow_download(
       navigation_state->common_params().allow_download);
   extra_data->set_transition_type(transition_type);
   extra_data->set_should_replace_current_entry(should_replace_current_entry);
   extra_data->set_transferred_request_child_id(
       navigation_state->start_params().transferred_request_child_id);
   extra_data->set_transferred_request_request_id(
       navigation_state->start_params().transferred_request_request_id);
   extra_data->set_service_worker_provider_id(provider_id);
   extra_data->set_stream_override(stream_override.Pass());
   request.setExtraData(extra_data);
 
   // TODO(creis): Update prefetching to work with out-of-process iframes.
-  WebFrame* top_frame = frame->top();
+  WebFrame* top_frame = frame_->top();
   if (top_frame && top_frame->isWebLocalFrame()) {
     DocumentState* top_document_state =
         DocumentState::FromDataSource(top_frame->dataSource());
     if (top_document_state) {
       // TODO(gavinp): separate out prefetching and prerender field trials
       // if the rel=prerender rel type is sticking around.
       if (request.requestContext() == WebURLRequest::RequestContextPrefetch)
         top_document_state->set_was_prefetcher(true);
     }
   }
@@ skipping 1494 matching lines @@
       switches::kEnableBrowserSideNavigation));
   DCHECK(request);
   // TODO(clamy): Execute the beforeunload event.
 
   // Note: At this stage, the goal is to apply all the modifications the
   // renderer wants to make to the request, and then send it to the browser, so
   // that the actual network request can be started. Ideally, all such
   // modifications should take place in willSendRequest, and in the
   // implementation of willSendRequest for the various InspectorAgents
   // (devtools).
-  //
-  // TODO(clamy): Apply devtools override.
-  // TODO(clamy): Make sure that navigation requests are not modified somewhere
-  // else in blink.
-  willSendRequest(frame_, 0, *request, blink::WebURLResponse());
 
   // TODO(clamy): Same-document navigations should not be sent back to the
   // browser.
   // TODO(clamy): Data urls should not be sent back to the browser either.
   bool should_replace_current_entry = false;
   WebDataSource* provisional_data_source = frame_->provisionalDataSource();
   WebDataSource* current_data_source = frame_->dataSource();
   WebDataSource* data_source =
       provisional_data_source ? provisional_data_source : current_data_source;
+  //
+  // TODO(clamy): Apply devtools override.
+  // TODO(clamy): Make sure that navigation requests are not modified somewhere
+  // else in blink.
+  willSendRequest(data_source, 0, *request, blink::WebURLResponse());
 
   // The current entry can only be replaced if there already is an entry in the
   // history list.
   if (data_source && render_view_->history_list_length_ > 0) {
     should_replace_current_entry = data_source->replacesCurrentHistoryItem();
   }
 
   // These values are assumed on the browser side for navigations. These checks
   // ensure the renderer has the correct values.
   DCHECK_EQ(FETCH_REQUEST_MODE_SAME_ORIGIN,
@@ skipping 281 matching lines @@
   mojo::ServiceProviderPtr service_provider(21);
   mojo::URLRequestPtr request(mojo::URLRequest::New());
   request->url = mojo::String::From(url);
   mojo_shell_->ConnectToApplication(request.Pass(), GetProxy(&service_provider),
                                     nullptr, nullptr,
                                     base::Bind(&OnGotContentHandlerID));
   return service_provider.Pass();
 }
 
 }  // namespace content