Move provisional navigation parameters to RenderFrame, and use the HistoryController to distribute …

content/renderer/history_controller.cc

 // Copyright 2014 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.
 
 /*
  * Copyright (C) 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved.
  *     (http://www.torchmobile.com/)
  *
@@ skipping 17 matching lines @@
  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "content/renderer/history_controller.h"
 
+#include "content/common/navigation_params.h"
 #include "content/renderer/render_frame_impl.h"
 #include "content/renderer/render_view_impl.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 
 using blink::WebFrame;
 using blink::WebHistoryCommitType;
 using blink::WebHistoryItem;
 using blink::WebURLRequest;
 
 namespace content {
 
 HistoryController::HistoryController(RenderViewImpl* render_view)
     : render_view_(render_view) {
 }
 
 HistoryController::~HistoryController() {
 }
 
-void HistoryController::GoToEntry(scoped_ptr<HistoryEntry> target_entry,
-                                  WebURLRequest::CachePolicy cache_policy) {
+void HistoryController::GoToEntry(
+    scoped_ptr<HistoryEntry> target_entry,
+    scoped_ptr<NavigationParams> navigation_params,
+    WebURLRequest::CachePolicy cache_policy) {
   HistoryFrameLoadVector same_document_loads;
   HistoryFrameLoadVector different_document_loads;
 
   provisional_entry_ = target_entry.Pass();
+  navigation_params_ = navigation_params.Pass();
 
   WebFrame* main_frame = render_view_->GetMainRenderFrame()->GetWebFrame();
   if (current_entry_) {
     RecursiveGoToEntry(
         main_frame, same_document_loads, different_document_loads);
   }
 
   if (same_document_loads.empty() && different_document_loads.empty()) {
     // If we don't have any frames to navigate at this point, either
     // (1) there is no previous history entry to compare against, or
     // (2) we were unable to match any frames by name. In the first case,
     // doing a different document navigation to the root item is the only valid
     // thing to do. In the second case, we should have been able to find a
     // frame to navigate based on names if this were a same document
     // navigation, so we can safely assume this is the different document case.
     different_document_loads.push_back(
         std::make_pair(main_frame, provisional_entry_->root()));
   }
 
-  for (size_t i = 0; i < same_document_loads.size(); ++i) {
-    WebFrame* frame = same_document_loads[i].first;
-    if (!RenderFrameImpl::FromWebFrame(frame))
+  for (const auto& item : same_document_loads) {
+    WebFrame* frame = item.first;
+    RenderFrameImpl* render_frame = RenderFrameImpl::FromWebFrame(frame);
+    if (!render_frame)
       continue;
-    frame->loadHistoryItem(same_document_loads[i].second,
+    render_frame->SetPendingNavigationParams(make_scoped_ptr(
+        new NavigationParams(*navigation_params_.get())));
+    frame->loadHistoryItem(item.second,
                            blink::WebHistorySameDocumentLoad,
                            cache_policy);
   }
-  for (size_t i = 0; i < different_document_loads.size(); ++i) {
-    WebFrame* frame = different_document_loads[i].first;
-    if (!RenderFrameImpl::FromWebFrame(frame))
+  for (const auto& item : different_document_loads) {
+    WebFrame* frame = item.first;
+    RenderFrameImpl* render_frame = RenderFrameImpl::FromWebFrame(frame);
+    if (!render_frame)
       continue;
-    frame->loadHistoryItem(different_document_loads[i].second,
+    render_frame->SetPendingNavigationParams(make_scoped_ptr(
+        new NavigationParams(*navigation_params_.get())));
+    frame->loadHistoryItem(item.second,
                            blink::WebHistoryDifferentDocumentLoad,
                            cache_policy);
   }
 }
 
 void HistoryController::RecursiveGoToEntry(
     WebFrame* frame,
     HistoryFrameLoadVector& same_document_loads,
     HistoryFrameLoadVector& different_document_loads) {
   DCHECK(provisional_entry_);
@@ skipping 55 matching lines @@
     UpdateForInitialLoadInChildFrame(frame, item);
   }
 }
 
 HistoryEntry* HistoryController::GetCurrentEntry() {
   return current_entry_.get();
 }
 
 WebHistoryItem HistoryController::GetItemForNewChildFrame(
     RenderFrameImpl* frame) const {
+  if (navigation_params_.get()) {
+    frame->SetPendingNavigationParams(make_scoped_ptr(
+        new NavigationParams(*navigation_params_.get())));
+  }
+
   if (!current_entry_)
     return WebHistoryItem();
   return current_entry_->GetItemForFrame(frame);
 }
 
 void HistoryController::RemoveChildrenForRedirect(RenderFrameImpl* frame) {
   if (!provisional_entry_)
     return;
   if (HistoryEntry::HistoryNode* node =
           provisional_entry_->GetHistoryNodeForFrame(frame))
     node->RemoveChildren();
 }
 
 void HistoryController::CreateNewBackForwardItem(
     RenderFrameImpl* target_frame,
     const WebHistoryItem& new_item,
     bool clone_children_of_target) {
   if (!current_entry_) {
     current_entry_.reset(
         new HistoryEntry(new_item, target_frame->GetRoutingID()));
   } else {
     current_entry_.reset(current_entry_->CloneAndReplace(
         new_item, clone_children_of_target, target_frame, render_view_));
   }
 }
 
 }  // namespace content