Pick frame to navigate in the browser process.

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 1073 matching lines @@
       WebURLRequest::UseProtocolCachePolicy;
   if (!RenderFrameImpl::PrepareRenderViewForNavigation(
           common_params.url, is_history_navigation, request_params, &is_reload,
           &cache_policy)) {
     Send(new FrameHostMsg_DidDropNavigation(routing_id_));
     return;
   }
 
   GetContentClient()->SetActiveURL(common_params.url);
 
-  WebFrame* frame = frame_;
-  if (!request_params.frame_to_navigate.empty()) {
-    // TODO(nasko): Move this lookup to the browser process.
-    frame = render_view_->webview()->findFrameByName(
-        WebString::fromUTF8(request_params.frame_to_navigate));
-    CHECK(frame) << "Invalid frame name passed: "
-                 << request_params.frame_to_navigate;
-  }
-
   // If this frame isn't in the same process as its parent, it will naively
   // assume that this is the first navigation in the iframe, but this may not
   // actually be the case. The PageTransition differentiates between the first
   // navigation in a subframe and subsequent navigations, so if this is a
   // subsequent navigation, force the frame's state machine forward.
   if (ui::PageTransitionCoreTypeIs(common_params.transition,
                                    ui::PAGE_TRANSITION_MANUAL_SUBFRAME)) {
     CHECK(frame_->parent());
     if (frame_->parent()->isWebRemoteFrame()) {
-      CHECK_EQ(frame, frame_);
       frame_->setCommittedFirstRealLoad();
     }
   }
 
   if (is_reload && !render_view_->history_controller()->GetCurrentEntry()) {
     // We cannot reload if we do not have any history state.  This happens, for
     // example, when recovering from a crash.
     is_reload = false;
     cache_policy = WebURLRequest::ReloadIgnoringCacheData;
   }
 
   pending_navigation_params_.reset(
       new NavigationParams(common_params, start_params, request_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 =
         (common_params.navigation_type ==
          FrameMsg_Navigate_Type::RELOAD_ORIGINAL_REQUEST_URL);
     bool ignore_cache = (common_params.navigation_type ==
                          FrameMsg_Navigate_Type::RELOAD_IGNORING_CACHE);
 
     if (reload_original_url)
-      frame->reloadWithOverrideURL(common_params.url, true);
+      frame_->reloadWithOverrideURL(common_params.url, true);
     else
-      frame->reload(ignore_cache);
+      frame_->reload(ignore_cache);
   } else if (is_history_navigation) {
     // We must know the page ID of the page we are navigating back to.
     DCHECK_NE(request_params.page_id, -1);
     scoped_ptr<HistoryEntry> entry =
         PageStateToHistoryEntry(request_params.page_state);
     if (entry) {
       // Ensure we didn't save the swapped out URL in UpdateState, since the
       // browser should never be telling us to navigate to swappedout://.
       CHECK(entry->root().urlString() != WebString::fromUTF8(kSwappedOutURL));
       scoped_ptr<NavigationParams> navigation_params(
           new NavigationParams(*pending_navigation_params_.get()));
       render_view_->history_controller()->GoToEntry(
           entry.Pass(), navigation_params.Pass(), cache_policy);
     }
   } else if (!common_params.base_url_for_data_url.is_empty()) {
-    LoadDataURL(common_params, frame);
+    LoadDataURL(common_params, frame_);
   } else {
     // Navigate to the given URL.
     WebURLRequest request = CreateURLRequestForNavigation(
         common_params, scoped_ptr<StreamOverrideParameters>(),
-        frame->isViewSourceModeEnabled());
+        frame_->isViewSourceModeEnabled());
 
     if (!start_params.extra_headers.empty()) {
       for (net::HttpUtil::HeadersIterator i(start_params.extra_headers.begin(),
                                             start_params.extra_headers.end(),
                                             "\n");
            i.GetNext();) {
         request.addHTTPHeaderField(WebString::fromUTF8(i.name()),
                                    WebString::fromUTF8(i.values()));
       }
     }
@@ skipping 13 matching lines @@
           WebData(data, start_params.browser_initiated_post_data.size()));
       request.setHTTPBody(http_body);
     }
 
     // A session history navigation should have been accompanied by state.
     CHECK_EQ(request_params.page_id, -1);
 
     // Record this before starting the load, we need a lower bound of this time
     // to sanitize the navigationStart override set below.
     base::TimeTicks renderer_navigation_start = base::TimeTicks::Now();
-    frame->loadRequest(request);
+    frame_->loadRequest(request);
 
-    UpdateFrameNavigationTiming(frame, request_params.browser_navigation_start,
+    UpdateFrameNavigationTiming(frame_, request_params.browser_navigation_start,
                                 renderer_navigation_start);
   }
 
   // In case LoadRequest failed before didCreateDataSource was called.
   pending_navigation_params_.reset();
 }
 
 void RenderFrameImpl::NavigateToSwappedOutURL() {
   // We use loadRequest instead of loadHTMLString because the former commits
   // synchronously.  Otherwise a new navigation can interrupt the navigation
@@ skipping 3672 matching lines @@
 #elif defined(ENABLE_BROWSER_CDMS)
         cdm_manager_,
 #endif
         this);
   }
 
   return cdm_factory_;
 }
 
 }  // namespace content