Add "frame to navigate" to NavigationEntry and plumb it to the RenderViewImpl

content/renderer/render_view_impl.cc

 // Copyright (c) 2012 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_view_impl.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/bind.h"
@@ skipping 1114 matching lines @@
   history_list_offset_ = params.current_history_list_offset;
   history_list_length_ = params.current_history_list_length;
   if (history_list_length_ >= 0)
     history_page_ids_.resize(history_list_length_, -1);
   if (params.pending_history_list_offset >= 0 &&
       params.pending_history_list_offset < history_list_length_)
     history_page_ids_[params.pending_history_list_offset] = params.page_id;
 
   GetContentClient()->SetActiveURL(params.url);
 
-  WebFrame* main_frame = webview()->mainFrame();
-  if (is_reload && main_frame->currentHistoryItem().isNull()) {
+  WebFrame* frame = webview()->mainFrame();
+  if (!params.frame_to_navigate.empty()) {
+    frame = webview()->findFrameByName(
+        WebString::fromUTF8(params.frame_to_navigate));
+    CHECK(frame) << "Invalid frame name passed: " << params.frame_to_navigate;
+  }
+
+  if (is_reload && frame->currentHistoryItem().isNull()) {
     // We cannot reload if we do not have any history state.  This happens, for
     // example, when recovering from a crash.  Our workaround here is a bit of
     // a hack since it means that reload after a crashed tab does not cause an
     // end-to-end cache validation.
     is_reload = false;
   }
 
   pending_navigation_params_.reset(new ViewMsg_Navigate_Params(params));
 
   // If we are reloading, then WebKit will use the history state of the current
   // page, so we should just ignore any given history state.  Otherwise, if we
   // have history state, then we need to navigate to it, which corresponds to a
   // back/forward navigation event.
   if (is_reload) {
     bool reload_original_url =
         (params.navigation_type ==
             ViewMsg_Navigate_Type::RELOAD_ORIGINAL_REQUEST_URL);
     bool ignore_cache = (params.navigation_type ==
                              ViewMsg_Navigate_Type::RELOAD_IGNORING_CACHE);
 
     if (reload_original_url)
-      main_frame->reloadWithOverrideURL(params.url, true);
+      frame->reloadWithOverrideURL(params.url, true);
     else
-      main_frame->reload(ignore_cache);
+      frame->reload(ignore_cache);
   } else if (!params.state.empty()) {
     // We must know the page ID of the page we are navigating back to.
     DCHECK_NE(params.page_id, -1);
     WebHistoryItem item = webkit_glue::HistoryItemFromString(params.state);
     if (!item.isNull()) {
       // Ensure we didn't save the swapped out URL in UpdateState, since the
       // browser should never be telling us to navigate to swappedout://.
       CHECK(item.urlString() != WebString::fromUTF8(kSwappedOutURL));
-      main_frame->loadHistoryItem(item);
+      frame->loadHistoryItem(item);
     }
   } else if (!params.base_url_for_data_url.is_empty()) {
     // A loadData request with a specified base URL.
     std::string mime_type, charset, data;
     if (net::DataURL::Parse(params.url, &mime_type, &charset, &data)) {
-      main_frame->loadData(
+      frame->loadData(
           WebData(data.c_str(), data.length()),
           WebString::fromUTF8(mime_type),
           WebString::fromUTF8(charset),
           params.base_url_for_data_url,
           params.history_url_for_data_url,
           false);
     } else {
       CHECK(false) <<
           "Invalid URL passed: " << params.url.possibly_invalid_spec();
     }
   } else {
     // Navigate to the given URL.
     WebURLRequest request(params.url);
 
     // A session history navigation should have been accompanied by state.
     CHECK_EQ(params.page_id, -1);
 
-    if (main_frame->isViewSourceModeEnabled())
+    if (frame->isViewSourceModeEnabled())
       request.setCachePolicy(WebURLRequest::ReturnCacheDataElseLoad);
 
     if (params.referrer.url.is_valid()) {
       WebString referrer = WebSecurityPolicy::generateReferrerHeader(
           params.referrer.policy,
           params.url,
           WebString::fromUTF8(params.referrer.url.spec()));
       if (!referrer.isEmpty())
         request.setHTTPHeaderField(WebString::fromUTF8("Referer"), referrer);
     }
@@ skipping 13 matching lines @@
       // Set post data.
       WebHTTPBody http_body;
       http_body.initialize();
       http_body.appendData(WebData(
           reinterpret_cast<const char*>(
               &params.browser_initiated_post_data.front()),
           params.browser_initiated_post_data.size()));
       request.setHTTPBody(http_body);
     }
 
-    main_frame->loadRequest(request);
+    frame->loadRequest(request);
   }
 
   // In case LoadRequest failed before DidCreateDataSource was called.
   pending_navigation_params_.reset();
 }
 
 bool RenderViewImpl::IsBackForwardToStaleEntry(
     const ViewMsg_Navigate_Params& params,
     bool is_reload) {
   // Make sure this isn't a back/forward to an entry we have already cropped
@@ skipping 5359 matching lines @@
 }
 #endif
 
 void RenderViewImpl::OnReleaseDisambiguationPopupDIB(
     TransportDIB::Handle dib_handle) {
   TransportDIB* dib = TransportDIB::CreateWithHandle(dib_handle);
   RenderProcess::current()->ReleaseTransportDIB(dib);
 }
 
 }  // namespace content