Start using RenderFrameProxyHost objects.

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 54 matching lines @@
 #include "content/renderer/media/media_stream_impl.h"
 #include "content/renderer/media/media_stream_renderer_factory.h"
 #include "content/renderer/media/midi_dispatcher.h"
 #include "content/renderer/media/render_media_log.h"
 #include "content/renderer/media/webcontentdecryptionmodule_impl.h"
 #include "content/renderer/media/webmediaplayer_impl.h"
 #include "content/renderer/media/webmediaplayer_ms.h"
 #include "content/renderer/media/webmediaplayer_params.h"
 #include "content/renderer/notification_provider.h"
 #include "content/renderer/npapi/plugin_channel_host.h"
+#include "content/renderer/render_frame_proxy.h"
 #include "content/renderer/render_process.h"
 #include "content/renderer/render_thread_impl.h"
 #include "content/renderer/render_view_impl.h"
 #include "content/renderer/render_widget_fullscreen_pepper.h"
 #include "content/renderer/renderer_webapplicationcachehost_impl.h"
 #include "content/renderer/renderer_webcolorchooser_impl.h"
 #include "content/renderer/screen_orientation/screen_orientation_dispatcher.h"
 #include "content/renderer/shared_worker_repository.h"
 #include "content/renderer/v8_value_converter_impl.h"
 #include "content/renderer/websharedworker_proxy.h"
@@ skipping 274 matching lines @@
 // static
 RenderFrameImpl* RenderFrameImpl::FromRoutingID(int32 routing_id) {
   RoutingIDFrameMap::iterator iter =
       g_routing_id_frame_map.Get().find(routing_id);
   if (iter != g_routing_id_frame_map.Get().end())
     return iter->second;
   return NULL;
 }
 
 // static
+void RenderFrameImpl::CreateFrame(int routing_id, int parent_routing_id) {
+  LOG(ERROR) << "RF::CreateFrame: " << routing_id << ", child of: "
+    << parent_routing_id;
+  CHECK_NE(MSG_ROUTING_NONE, parent_routing_id);
+
+  RenderFrameProxy* proxy = RenderFrameProxy::FromRoutingID(parent_routing_id);
+  LOG(ERROR) << "RF::CreateFrame: " << routing_id << " proxy:" << proxy;
+
+  // If the browser is sending a valid parent routing id, it better be created
+  // and registered.
+  CHECK(proxy);
+  blink::WebRemoteFrame* parent_web_frame = proxy->GetWebFrame();
+  LOG(ERROR) << "RF::CreateFrame: " << routing_id
+      << " render_view:" << proxy->render_view() << ", parent_web_frame:" << parent_web_frame;
+
+  // Create the RenderFrame and WebLocalFrame, linking the two.
+  RenderFrameImpl* render_frame = RenderFrameImpl::Create(
+      proxy->render_view(), routing_id);
+  blink::WebLocalFrame* web_frame = parent_web_frame->createLocalChild("", render_frame);
+  render_frame->SetWebFrame(web_frame);
+  render_frame->Initialize();
+
+  LOG(ERROR) << "RF::CreateFrame: " << routing_id
+      << " frame parent:" << render_frame->frame_->parent();
+}
+
+// static
 RenderFrame* RenderFrame::FromWebFrame(blink::WebFrame* web_frame) {
   return RenderFrameImpl::FromWebFrame(web_frame);
 }
 
+// static
 RenderFrameImpl* RenderFrameImpl::FromWebFrame(blink::WebFrame* web_frame) {
   FrameMap::iterator iter = g_frame_map.Get().find(web_frame);
   if (iter != g_frame_map.Get().end())
     return iter->second;
   return NULL;
 }
 
 // static
 void RenderFrameImpl::InstallCreateHook(
     RenderFrameImpl* (*create_render_frame_impl)(RenderViewImpl*, int32)) {
@@ skipping 18 matching lines @@
       midi_dispatcher_(NULL),
 #if defined(OS_ANDROID)
       media_player_manager_(NULL),
 #endif
 #if defined(ENABLE_BROWSER_CDMS)
       cdm_manager_(NULL),
 #endif
       geolocation_dispatcher_(NULL),
       screen_orientation_dispatcher_(NULL),
       weak_factory_(this) {
+  LOG(ERROR) << "RF[" << this << "]::RF:"
+      << " routing_id:" << routing_id;
+
   RenderThread::Get()->AddRoute(routing_id_, this);
 
   std::pair<RoutingIDFrameMap::iterator, bool> result =
       g_routing_id_frame_map.Get().insert(std::make_pair(routing_id_, this));
   CHECK(result.second) << "Inserting a duplicate item.";
 
   render_view_->RegisterRenderFrame(this);
 
 #if defined(OS_ANDROID)
   new JavaBridgeDispatcher(this);
 #endif
 
 #if defined(ENABLE_NOTIFICATIONS)
   notification_provider_ = new NotificationProvider(this);
 #endif
 }
 
 RenderFrameImpl::~RenderFrameImpl() {
   FOR_EACH_OBSERVER(RenderFrameObserver, observers_, RenderFrameGone());
   FOR_EACH_OBSERVER(RenderFrameObserver, observers_, OnDestruct());
 
 #if defined(OS_ANDROID) && defined(VIDEO_HOLE)
   if (media_player_manager_)
     render_view_->UnregisterVideoHoleFrame(this);
 #endif
 
+  LOG(ERROR) << "RF[" << this << "]::~RF";
+
   render_view_->UnregisterRenderFrame(this);
   g_routing_id_frame_map.Get().erase(routing_id_);
   RenderThread::Get()->RemoveRoute(routing_id_);
 }
 
 void RenderFrameImpl::SetWebFrame(blink::WebLocalFrame* web_frame) {
   DCHECK(!frame_);
 
+  LOG(ERROR) << "RF[" << this << "]::SetWebFrame: map.insert(" << web_frame << ", " << this << ")";
   std::pair<FrameMap::iterator, bool> result = g_frame_map.Get().insert(
       std::make_pair(web_frame, this));
   CHECK(result.second) << "Inserting a duplicate item.";
 
   frame_ = web_frame;
 }
 
 void RenderFrameImpl::Initialize() {
 #if defined(ENABLE_PLUGINS)
   new PepperBrowserConnection(this);
@@ skipping 191 matching lines @@
   pepper_composition_text_.clear();
 }
 
 #endif  // ENABLE_PLUGINS
 
 bool RenderFrameImpl::Send(IPC::Message* message) {
   if (is_detaching_) {
     delete message;
     return false;
   }
-  if (is_swapped_out_ || render_view_->is_swapped_out()) {
+  if (frame_->parent() == NULL &&
+      (is_swapped_out_ || render_view_->is_swapped_out())) {
+    LOG(ERROR) << "RF[" << this << "]::Send:"
+        << " main frame in swapped out state";
     if (!SwappedOutMessages::CanSendWhileSwappedOut(message)) {
       delete message;
       return false;
     }
+
     // In most cases, send IPCs through the proxy when swapped out. In some
     // calls the associated RenderViewImpl routing id is used to send
     // messages, so don't use the proxy.
     if (render_frame_proxy_ && message->routing_id() == routing_id_)
       return render_frame_proxy_->Send(message);
   }
 
   return RenderThread::Get()->Send(message);
 }
 
 bool RenderFrameImpl::OnMessageReceived(const IPC::Message& msg) {
-  GetContentClient()->SetActiveURL(frame_->document().url());
+  //GetContentClient()->SetActiveURL(frame_->document().url());
 
   ObserverListBase<RenderFrameObserver>::Iterator it(observers_);
   RenderFrameObserver* observer;
   while ((observer = it.GetNext()) != NULL) {
     if (observer->OnMessageReceived(msg))
       return true;
   }
 
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(RenderFrameImpl, msg)
@@ skipping 31 matching lines @@
                         OnAddStyleSheetByURL)
 #if defined(OS_MACOSX)
     IPC_MESSAGE_HANDLER(InputMsg_CopyToFindPboard, OnCopyToFindPboard)
 #endif
   IPC_END_MESSAGE_MAP()
 
   return handled;
 }
 
 void RenderFrameImpl::OnNavigate(const FrameMsg_Navigate_Params& params) {
+  LOG(ERROR) << "RF[" << this << "]::OnNavigate:" << routing_id_ << ":" << params.url;
   MaybeHandleDebugURL(params.url);
-  if (!render_view_->webview())
+  if (!render_view_->webview()) {
+    LOG(ERROR) << "RF[" << this << "]::OnNavigate:" << routing_id_ << ": no webview()";
     return;
+  }
 
   FOR_EACH_OBSERVER(
       RenderViewObserver, render_view_->observers_, Navigate(params.url));
 
   bool is_reload = RenderViewImpl::IsReload(params);
   WebURLRequest::CachePolicy cache_policy =
       WebURLRequest::UseProtocolCachePolicy;
 
   // If this is a stale back/forward (due to a recent navigation the browser
   // didn't know about), ignore it.
-  if (render_view_->IsBackForwardToStaleEntry(params, is_reload))
+  if (render_view_->IsBackForwardToStaleEntry(params, is_reload)) {
+    LOG(ERROR) << "RF[" << this << "]::OnNavigate:" << routing_id_ << ": stale entry";
     return;
+  }
 
   // Swap this renderer back in if necessary.
-  if (render_view_->is_swapped_out_) {
+  if (render_view_->is_swapped_out_ &&
+      GetWebFrame() == render_view_->webview()->mainFrame()) {
+    LOG(ERROR) << "RF[" << this << "]::OnNavigate:"
+        << " RV is swapped out, frame is the top-level, so unswap";
     // We marked the view as hidden when swapping the view out, so be sure to
     // reset the visibility state before navigating to the new URL.
     render_view_->webview()->setVisibilityState(
         render_view_->visibilityState(), false);
 
     // If this is an attempt to reload while we are swapped out, we should not
     // reload swappedout://, but the previous page, which is stored in
     // params.state.  Setting is_reload to false will treat this like a back
     // navigation to accomplish that.
     is_reload = false;
     cache_policy = WebURLRequest::ReloadIgnoringCacheData;
 
     // We refresh timezone when a view is swapped in since timezone
     // can get out of sync when the system timezone is updated while
     // the view is swapped out.
     RenderThreadImpl::NotifyTimezoneChange();
 
     render_view_->SetSwappedOut(false);
     is_swapped_out_ = false;
+  } else {
+    LOG(ERROR) << "RF[" << this << "]::OnNavigate:"
+        << " RV is swapped out, but frame isn't the top-level one";
   }
 
   if (params.should_clear_history_list) {
     CHECK_EQ(params.pending_history_list_offset, -1);
     CHECK_EQ(params.current_history_list_offset, -1);
     CHECK_EQ(params.current_history_list_length, 0);
   }
   render_view_->history_list_offset_ = params.current_history_list_offset;
   render_view_->history_list_length_ = params.current_history_list_length;
   if (render_view_->history_list_length_ >= 0) {
@@ skipping 24 matching lines @@
   }
 
   render_view_->pending_navigation_params_.reset(
       new FrameMsg_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) {
+    LOG(ERROR) << "RF[" << this << "]::OnNavigate:" << routing_id_ << ": reload";
     bool reload_original_url =
         (params.navigation_type ==
             FrameMsg_Navigate_Type::RELOAD_ORIGINAL_REQUEST_URL);
     bool ignore_cache = (params.navigation_type ==
                              FrameMsg_Navigate_Type::RELOAD_IGNORING_CACHE);
 
     if (reload_original_url)
       frame->reloadWithOverrideURL(params.url, true);
     else
       frame->reload(ignore_cache);
   } else if (params.page_state.IsValid()) {
+    LOG(ERROR) << "RF[" << this << "]::OnNavigate:" << routing_id_ << ": valid page state";
     // We must know the page ID of the page we are navigating back to.
     DCHECK_NE(params.page_id, -1);
     scoped_ptr<HistoryEntry> entry =
         PageStateToHistoryEntry(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));
       render_view_->history_controller()->GoToEntry(entry.Pass(), cache_policy);
     }
   } else if (!params.base_url_for_data_url.is_empty()) {
+    LOG(ERROR) << "RF[" << this << "]::OnNavigate:" << routing_id_ << ": data URL";
     // A loadData request with a specified base URL.
     std::string mime_type, charset, data;
     if (net::DataURL::Parse(params.url, &mime_type, &charset, &data)) {
       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);
+    LOG(ERROR) << "RF[" << this << "]::OnNavigate:" << routing_id_ << ": navigate to URL";
 
     // A session history navigation should have been accompanied by state.
     CHECK_EQ(params.page_id, -1);
 
     if (frame->isViewSourceModeEnabled())
       request.setCachePolicy(WebURLRequest::ReturnCacheDataElseLoad);
 
     if (params.referrer.url.is_valid()) {
       WebString referrer = WebSecurityPolicy::generateReferrerHeader(
           params.referrer.policy,
@@ skipping 59 matching lines @@
   base::TimeTicks before_unload_start_time = base::TimeTicks::Now();
   bool proceed = frame_->dispatchBeforeUnloadEvent();
   base::TimeTicks before_unload_end_time = base::TimeTicks::Now();
   Send(new FrameHostMsg_BeforeUnload_ACK(routing_id_, proceed,
                                          before_unload_start_time,
                                          before_unload_end_time));
 }
 
 void RenderFrameImpl::OnSwapOut(int proxy_routing_id) {
   RenderFrameProxy* proxy = NULL;
+  bool is_site_per_process =
+      CommandLine::ForCurrentProcess()->HasSwitch(switches::kSitePerProcess);
 
   // Only run unload if we're not swapped out yet, but send the ack either way.
   if (!is_swapped_out_ || !render_view_->is_swapped_out_) {
     // Swap this RenderFrame out so the frame can navigate to a page rendered by
     // a different process.  This involves running the unload handler and
     // clearing the page.  Once WasSwappedOut is called, we also allow this
     // process to exit if there are no other active RenderFrames in it.
 
     // Send an UpdateState message before we get swapped out. Create the
     // RenderFrameProxy as well so its routing id is registered for receiving
     // IPC messages.
     render_view_->SyncNavigationState();
-    proxy = RenderFrameProxy::CreateFrameProxy(proxy_routing_id, routing_id_);
+    proxy = RenderFrameProxy::CreateProxyForFrame(
+        proxy_routing_id, routing_id_);
 
     // Synchronously run the unload handler before sending the ACK.
     // TODO(creis): Call dispatchUnloadEvent unconditionally here to support
     // unload on subframes as well.
     if (!frame_->parent())
       frame_->dispatchUnloadEvent();
 
     // Swap out and stop sending any IPC messages that are not ACKs.
     if (!frame_->parent())
       render_view_->SetSwappedOut(true);
@@ skipping 12 matching lines @@
 
     // Let subframes know that the frame is now rendered remotely, for the
     // purposes of compositing and input events.
     if (frame_->parent())
       frame_->setIsRemote(true);
 
     // Replace the page with a blank dummy URL. The unload handler will not be
     // run a second time, thanks to a check in FrameLoader::stopLoading.
     // TODO(creis): Need to add a better way to do this that avoids running the
     // beforeunload handler. For now, we just run it a second time silently.
-    render_view_->NavigateToSwappedOutURL(frame_);
+    if (!is_site_per_process || frame_->parent() == NULL) {
+      LOG(ERROR) << "RF[" << this << "]::OnSwapOut:"
+          << " navigate to swappedout://";
+      render_view_->NavigateToSwappedOutURL(frame_);
+    }
 
     // Let WebKit know that this view is hidden so it can drop resources and
     // stop compositing.
     // TODO(creis): Support this for subframes as well.
     if (!frame_->parent()) {
       render_view_->webview()->setVisibilityState(
           blink::WebPageVisibilityStateHidden, false);
     }
   }
 
   // It is now safe to show modal dialogs again.
   // TODO(creis): Deal with modal dialogs from subframes.
   if (!frame_->parent())
     render_view_->suppress_dialogs_until_swap_out_ = false;
 
   Send(new FrameHostMsg_SwapOut_ACK(routing_id_));
 
   // Now that all of the cleanup is complete and the browser side is notified,
   // start using the RenderFrameProxy, if one is created.
-  if (proxy)
-    set_render_frame_proxy(proxy);
+  if (proxy) {
+    if (frame_->parent()) {
+      LOG(ERROR) << "RF[" << this << "]::OnSwapOut:"
+          << " will swap frames";
+      frame_->swap(proxy->GetWebFrame());
+      if (is_site_per_process) {
+        // TODO(nasko): delete the frame here, since we've replaced it with a
+        // proxy.
+      }
+    } else {
+      LOG(ERROR) << "RF[" << this << "]::OnSwapOut:"
+          << " parent, so will reuse RF";
+      set_render_frame_proxy(proxy);
+    }
+  }
 }
 
 void RenderFrameImpl::OnContextMenuClosed(
     const CustomContextMenuContext& custom_context) {
   if (custom_context.request_id) {
     // External request, should be in our map.
     ContextMenuClient* client =
         pending_context_menus_.Lookup(custom_context.request_id);
     if (client) {
       client->OnMenuClosed(custom_context.request_id);
@@ skipping 519 matching lines @@
   FOR_EACH_OBSERVER(RenderViewObserver, render_view_->observers(),
                     FrameDetached(frame));
 
   // We need to clean up subframes by removing them from the map and deleting
   // the RenderFrameImpl.  In contrast, the main frame is owned by its
   // containing RenderViewHost (so that they have the same lifetime), so only
   // removal from the map is needed and no deletion.
   FrameMap::iterator it = g_frame_map.Get().find(frame);
   CHECK(it != g_frame_map.Get().end());
   CHECK_EQ(it->second, this);
+  LOG(ERROR) << "RF[" << this << "]::map.erase:" << frame;
   g_frame_map.Get().erase(it);
 
   if (is_subframe)
     frame->parent()->removeChild(frame);
 
   // |frame| is invalid after here.
   frame->close();
 
   if (is_subframe) {
     delete this;
@@ skipping 79 matching lines @@
                                             static_cast<int32>(source_line),
                                             source_name));
 }
 
 void RenderFrameImpl::loadURLExternally(
     blink::WebLocalFrame* frame,
     const blink::WebURLRequest& request,
     blink::WebNavigationPolicy policy,
     const blink::WebString& suggested_name) {
   DCHECK(!frame_ || frame_ == frame);
+  LOG(ERROR) << "RF[" << this << "]::loadURLExternally:"
+      << " url:" << request.url()
+      << " policy:" << policy;
+
   Referrer referrer(RenderViewImpl::GetReferrerFromRequest(frame, request));
   if (policy == blink::WebNavigationPolicyDownload) {
     render_view_->Send(new ViewHostMsg_DownloadUrl(render_view_->GetRoutingID(),
                                                    request.url(), referrer,
                                                    suggested_name, false));
   } else if (policy == blink::WebNavigationPolicyDownloadTo) {
     render_view_->Send(new ViewHostMsg_DownloadUrl(render_view_->GetRoutingID(),
                                                    request.url(), referrer,
                                                    suggested_name, true));
   } else {
     OpenURL(frame, request.url(), referrer, policy);
   }
 }
 
 blink::WebNavigationPolicy RenderFrameImpl::decidePolicyForNavigation(
     blink::WebLocalFrame* frame,
     blink::WebDataSource::ExtraData* extra_data,
     const blink::WebURLRequest& request,
     blink::WebNavigationType type,
     blink::WebNavigationPolicy default_policy,
     bool is_redirect) {
   DCHECK(!frame_ || frame_ == frame);
-  return DecidePolicyForNavigation(
+  WebNavigationPolicy value = DecidePolicyForNavigation(
       this, frame, extra_data, request, type, default_policy, is_redirect);
+  LOG(ERROR) << "RF[" << this << "]::decidePolicyForNavigation:"
+      << " returning:" << value;
+  return value;
 }
 
 blink::WebHistoryItem RenderFrameImpl::historyItemForNewChildFrame(
     blink::WebFrame* frame) {
   DCHECK(!frame_ || frame_ == frame);
   return render_view_->history_controller()->GetItemForNewChildFrame(this);
 }
 
 void RenderFrameImpl::willSendSubmitEvent(blink::WebLocalFrame* frame,
                                           const blink::WebFormElement& form) {
@@ skipping 51 matching lines @@
   DCHECK(!frame_ || frame_ == frame);
   WebDataSource* ds = frame->provisionalDataSource();
 
   // In fast/loader/stop-provisional-loads.html, we abort the load before this
   // callback is invoked.
   if (!ds)
     return;
 
   DocumentState* document_state = DocumentState::FromDataSource(ds);
 
+  LOG(ERROR) << "RF[" << this << "]::didStartProvisionalLoad: "
+      << " frame:" << frame
+      << " routing:" << routing_id_
+      << " url:" << ds->request().url();
   // We should only navigate to swappedout:// when is_swapped_out_ is true.
   CHECK((ds->request().url() != GURL(kSwappedOutURL)) ||
         is_swapped_out_ ||
         render_view_->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()) {
     double event_time = ds->triggeringEventTime();
     if (event_time != 0.0)
@@ skipping 13 matching lines @@
     // marked with AUTO_SUBFRAME. See also didFailProvisionalLoad for how we
     // handle loading of error pages.
     document_state->navigation_state()->set_transition_type(
         PAGE_TRANSITION_AUTO_SUBFRAME);
   }
 
   FOR_EACH_OBSERVER(RenderViewObserver, render_view_->observers(),
                     DidStartProvisionalLoad(frame));
   FOR_EACH_OBSERVER(RenderFrameObserver, observers_, DidStartProvisionalLoad());
 
-  int parent_routing_id = frame->parent() ?
-      FromWebFrame(frame->parent())->GetRoutingID() : -1;
+  int parent_routing_id = -1;
+  if (frame->parent()) {
+    if (frame->parent()->isWebLocalFrame()) {
+      LOG(ERROR) << "RF[" << this << "]::didStartProvisionalLoad:"
+        << " local frame: FromWebFrame(parent): " << FromWebFrame(frame->parent());
+      parent_routing_id = FromWebFrame(frame->parent())->GetRoutingID();
+    } else {
+      LOG(ERROR) << "RF[" << this << "]::didStartProvisionalLoad:"
+        << " remote frame: FromWebFrame(parent): " <<
+            RenderFrameProxy::FromWebFrame(frame->parent());
+      parent_routing_id =
+          RenderFrameProxy::FromWebFrame(frame->parent())->routing_id();
+    }
+  }
   Send(new FrameHostMsg_DidStartProvisionalLoadForFrame(
        routing_id_, parent_routing_id, ds->request().url()));
 }
 
 void RenderFrameImpl::didReceiveServerRedirectForProvisionalLoad(
     blink::WebLocalFrame* frame) {
   DCHECK(!frame_ || frame_ == frame);
   render_view_->history_controller()->RemoveChildrenForRedirect(this);
   if (frame->parent())
     return;
@@ skipping 126 matching lines @@
   DCHECK(!frame_ || frame_ == frame);
   DocumentState* document_state =
       DocumentState::FromDataSource(frame->dataSource());
   NavigationState* navigation_state = document_state->navigation_state();
 
   // When we perform a new navigation, we need to update the last committed
   // session history entry with state for the page we are leaving. Do this
   // before updating the HistoryController state.
   render_view_->UpdateSessionHistory(frame);
 
+  LOG(ERROR) << "RF[" << this << "]::didCommitProvisionalLoad:"
+    << " frame:" << frame
+    << " commit:" << commit_type
+    << " url:" << GetLoadingUrl();
+
   render_view_->history_controller()->UpdateForCommit(this, item, commit_type,
       navigation_state->was_within_same_page());
 
   InternalDocumentStateData* internal_data =
       InternalDocumentStateData::FromDocumentState(document_state);
 
   if (document_state->commit_load_time().is_null())
     document_state->set_commit_load_time(Time::Now());
 
   if (internal_data->must_reset_scroll_and_scale_state()) {
@@ skipping 423 matching lines @@
   // 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.targetType() == blink::WebURLRequest::TargetIsMainFrame) {
       request.setFirstPartyForCookies(request.url());
     } else {
-      request.setFirstPartyForCookies(
-          frame->top()->document().firstPartyForCookies());
+      // TODO(nasko): When the top-level frame is remote, there is no document.
+      // This is broken and should be fixed to propagate the URL.
+      WebFrame* top = frame->top();
+      if (top->isWebLocalFrame()) {
+        request.setFirstPartyForCookies(
+            frame->top()->document().firstPartyForCookies());
+      }
     }
   }
 
   WebFrame* top_frame = frame->top();
-  if (!top_frame)
+  // TODO(nasko): Hack around asking about top-frame data source.
+  if (!top_frame || top_frame->isWebRemoteFrame())
     top_frame = frame;
   WebDataSource* provisional_data_source = top_frame->provisionalDataSource();
   WebDataSource* top_data_source = top_frame->dataSource();
   WebDataSource* data_source =
       provisional_data_source ? provisional_data_source : top_data_source;
 
   PageTransition transition_type = PAGE_TRANSITION_LINK;
   DocumentState* document_state = DocumentState::FromDataSource(data_source);
   DCHECK(document_state);
   InternalDocumentStateData* internal_data =
@@ skipping 72 matching lines @@
               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();
   }
 
-  int parent_routing_id = frame->parent() ?
-      FromWebFrame(frame->parent())->GetRoutingID() : -1;
+  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_was_after_preconnect_request(was_after_preconnect_request);
   extra_data->set_render_frame_id(routing_id_);
   extra_data->set_is_main_frame(frame == top_frame);
   extra_data->set_frame_origin(
       GURL(frame->document().securityOrigin().toString()));
   extra_data->set_parent_is_main_frame(frame->parent() == top_frame);
   extra_data->set_parent_render_frame_id(parent_routing_id);
@@ skipping 650 matching lines @@
 }
 
 WebNavigationPolicy RenderFrameImpl::DecidePolicyForNavigation(
     RenderFrame* render_frame,
     WebFrame* frame,
     WebDataSource::ExtraData* extraData,
     const WebURLRequest& request,
     WebNavigationType type,
     WebNavigationPolicy default_policy,
     bool is_redirect) {
+  LOG(ERROR) << "RF[" << this << "]::DecidePolicyForNavigation:"
+      << " url:" << request.url();
+
 #ifdef OS_ANDROID
   // The handlenavigation API is deprecated and will be removed once
   // crbug.com/325351 is resolved.
   if (request.url() != GURL(kSwappedOutURL) &&
       GetContentClient()->renderer()->HandleNavigation(
           render_frame,
           static_cast<DocumentState*>(extraData),
           render_view_->opener_id_,
           frame,
           request,
           type,
           default_policy,
           is_redirect)) {
+    LOG(ERROR) << "RF[" << this << "]::DecidePolicyForNavigation:"
+        << " url != swapped out && client->HandleNavigation";
     return blink::WebNavigationPolicyIgnore;
   }
 #endif
 
   Referrer referrer(RenderViewImpl::GetReferrerFromRequest(frame, request));
+  const CommandLine& command_line = *CommandLine::ForCurrentProcess();
 
-  if (is_swapped_out_ || render_view_->is_swapped_out()) {
-    if (request.url() != GURL(kSwappedOutURL)) {
-      // Targeted links may try to navigate a swapped out frame.  Allow the
-      // browser process to navigate the tab instead.  Note that it is also
-      // possible for non-targeted navigations (from this view) to arrive
-      // here just after we are swapped out.  It's ok to send them to the
-      // browser, as long as they're for the top level frame.
-      // TODO(creis): Ensure this supports targeted form submissions when
-      // fixing http://crbug.com/101395.
-      if (frame->parent() == NULL) {
-        OpenURL(frame, request.url(), referrer, default_policy);
-        return blink::WebNavigationPolicyIgnore;  // Suppress the load here.
+  LOG(ERROR) << "RF[" << this << "]::DecidePolicyForNavigation:"
+      << " is_swapped_out_:" << is_swapped_out_
+      << " rv->is_swapped_out():" << render_view_->is_swapped_out();
+  bool is_subframe = !!frame->parent();
+
+  if (command_line.HasSwitch(switches::kSitePerProcess) && is_subframe) {
+    LOG(ERROR)
+        << "RF[" << this << "]::DecidePolicyForNavigation:"
+        << " --site-per-process, so ignore swapped out state for subframes";
+  } else {
+    if (is_swapped_out_ || render_view_->is_swapped_out()) {
+      if (request.url() != GURL(kSwappedOutURL)) {
+        // Targeted links may try to navigate a swapped out frame.  Allow the
+        // browser process to navigate the tab instead.  Note that it is also
+        // possible for non-targeted navigations (from this view) to arrive
+        // here just after we are swapped out.  It's ok to send them to the
+        // browser, as long as they're for the top level frame.
+        // TODO(creis): Ensure this supports targeted form submissions when
+        // fixing http://crbug.com/101395.
+        if (frame->parent() == NULL) {
+          LOG(ERROR) << "RF[" << this << "]::DecidePolicyForNavigation:"
+                     << " OpenURL due to no parent frame";
+          OpenURL(frame, request.url(), referrer, default_policy);
+          return blink::WebNavigationPolicyIgnore;  // Suppress the load here.
+        }
+
+        // We should otherwise ignore in-process iframe navigations, if they
+        // arrive just after we are swapped out.
+        LOG(ERROR) << "RF[" << this << "]::DecidePolicyForNavigation:"
+                   << " ignore iframe navigation in swapped out state";
+        return blink::WebNavigationPolicyIgnore;
       }
 
-      // We should otherwise ignore in-process iframe navigations, if they
-      // arrive just after we are swapped out.
-      return blink::WebNavigationPolicyIgnore;
+      LOG(ERROR) << "RF[" << this << "]::DecidePolicyForNavigation:"
+                 << " allow kSwappedOutURL";
+      // Allow kSwappedOutURL to complete.
+      return default_policy;
     }
-
-    // Allow kSwappedOutURL to complete.
-    return default_policy;
   }
 
   // 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.url();
 
   // A content initiated navigation may have originated from a link-click,
   // script, drag-n-drop operation, etc.
   bool is_content_initiated = static_cast<DocumentState*>(extraData)->
           navigation_state()->is_content_initiated();
 
   // Experimental:
   // If --enable-strict-site-isolation or --site-per-process is enabled, send
   // all top-level navigations to the browser to let it swap processes when
   // crossing site boundaries.  This is currently expected to break some script
   // calls and navigations, such as form submissions.
-  const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   bool force_swap_due_to_flag =
       command_line.HasSwitch(switches::kEnableStrictSiteIsolation) ||
       command_line.HasSwitch(switches::kSitePerProcess);
   if (force_swap_due_to_flag &&
       !frame->parent() && (is_content_initiated || is_redirect)) {
     WebString origin_str = frame->document().securityOrigin().toString();
     GURL frame_url(origin_str.utf8().data());
     // TODO(cevans): revisit whether this site check is still necessary once
     // crbug.com/101395 is fixed.
     bool same_domain_or_host =
         net::registry_controlled_domains::SameDomainOrHost(
             frame_url,
             url,
             net::registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES);
+    LOG(ERROR) << "RF[" << this << "]::DecidePolicyForNavigation:"
+        << " force swap from flags, same_domain:" << same_domain_or_host;
     if (!same_domain_or_host || frame_url.scheme() != url.scheme()) {
+      LOG(ERROR) << "RF[" << this << "]::DecidePolicyForNavigation:"
+          << " OpenURL since force swap and not same domain";
       OpenURL(frame, url, referrer, default_policy);
       return blink::WebNavigationPolicyIgnore;
     }
   }
 
   // If the browser is interested, then give it a chance to look at the request.
   if (is_content_initiated) {
     bool is_form_post = ((type == blink::WebNavigationTypeFormSubmitted) ||
                          (type == blink::WebNavigationTypeFormResubmitted)) &&
                         EqualsASCII(request.httpMethod(), "POST");
     bool browser_handles_request =
         render_view_->renderer_preferences_
             .browser_handles_non_local_top_level_requests
         && IsNonLocalTopLevelNavigation(url, frame, type, is_form_post);
     if (!browser_handles_request) {
       browser_handles_request = IsTopLevelNavigation(frame) &&
           render_view_->renderer_preferences_
               .browser_handles_all_top_level_requests;
     }
 
     if (browser_handles_request) {
       // Reset these counters as the RenderView could be reused for the next
       // navigation.
       render_view_->page_id_ = -1;
       render_view_->last_page_id_sent_to_browser_ = -1;
+      LOG(ERROR) << "RF[" << this << "]::DecidePolicyForNavigation:"
+          << " OpenURL since browser handles request";
       OpenURL(frame, url, referrer, default_policy);
       return blink::WebNavigationPolicyIgnore;  // Suppress the load here.
     }
   }
 
   // Use the frame's original request's URL rather than the document's URL for
   // subsequent checks.  For a popup, the document's URL may become the opener
   // window's URL if the opener has called document.write().
   // See http://crbug.com/93517.
   GURL old_url(frame->dataSource()->request().url());
@@ skipping 43 matching lines @@
     }
 
     if (!should_fork) {
       // Give the embedder a chance.
       should_fork = GetContentClient()->renderer()->ShouldFork(
           frame, url, request.httpMethod().utf8(), is_initial_navigation,
           is_redirect, &send_referrer);
     }
 
     if (should_fork) {
+      LOG(ERROR) << "RF[" << this << "]::DecidePolicyForNavigation:"
+          << " OpenURL since should fork";
       OpenURL(
           frame, url, send_referrer ? referrer : Referrer(), default_policy);
       return blink::WebNavigationPolicyIgnore;  // 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
@@ skipping 19 matching lines @@
       // Must be a top-level frame.
       frame->parent() == NULL &&
       // Must not have issued the request from this page.
       is_content_initiated &&
       // Must be targeted at the current tab.
       default_policy == blink::WebNavigationPolicyCurrentTab &&
       // Must be a JavaScript navigation, which appears as "other".
       type == blink::WebNavigationTypeOther;
 
   if (is_fork) {
+    LOG(ERROR) << "RF[" << this << "]::DecidePolicyForNavigation:"
+        << " OpenURL since is_fork";
     // Open the URL via the browser, not via WebKit.
     OpenURL(frame, url, Referrer(), default_policy);
     return blink::WebNavigationPolicyIgnore;
   }
 
   return default_policy;
 }
 
 void RenderFrameImpl::OpenURL(WebFrame* frame,
                               const GURL& url,
@@ skipping 227 matching lines @@
 
 #if defined(ENABLE_BROWSER_CDMS)
 RendererCdmManager* RenderFrameImpl::GetCdmManager() {
   if (!cdm_manager_)
     cdm_manager_ = new RendererCdmManager(this);
   return cdm_manager_;
 }
 #endif  // defined(ENABLE_BROWSER_CDMS)
 
 }  // namespace content