Disable support for swapped out RenderFrame(Host) on desktop.

content/browser/frame_host/render_frame_host_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/browser/frame_host/render_frame_host_impl.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/containers/hash_tables.h"
 #include "base/lazy_instance.h"
@@ skipping 149 matching lines @@
       unload_ack_is_for_navigation_(false),
       is_loading_(false),
       pending_commit_(false),
       accessibility_reset_token_(0),
       accessibility_reset_count_(0),
       no_create_browser_accessibility_manager_for_testing_(false),
       weak_ptr_factory_(this) {
   bool is_swapped_out = !!(flags & CREATE_RF_SWAPPED_OUT);
   bool hidden = !!(flags & CREATE_RF_HIDDEN);
   frame_tree_->AddRenderViewHostRef(render_view_host_);
+
+  LOG(ERROR) << "RFH[" << this << "]::RFH: "
+    << " routing_id:" << routing_id
+    << " swapped:" << is_swapped_out
+    << " hidden:" << hidden
+    << " site:" << site_instance_->GetSiteURL();
+
   GetProcess()->AddRoute(routing_id_, this);
   g_routing_id_frame_map.Get().insert(std::make_pair(
       RenderFrameHostID(GetProcess()->GetID(), routing_id_),
       this));
 
   if (is_swapped_out) {
     rfh_state_ = STATE_SWAPPED_OUT;
   } else {
     rfh_state_ = STATE_DEFAULT;
     GetSiteInstance()->increment_active_frame_count();
@@ skipping 34 matching lines @@
   swapout_event_monitor_timeout_.reset();
 
   for (const auto& iter: visual_state_callbacks_) {
     iter.second.Run(false);
   }
 
   if (render_widget_host_) {
     // Shutdown causes the RenderWidgetHost to delete itself.
     render_widget_host_->Shutdown();
   }
+  LOG(ERROR) << "RFH[" << this << "]::~RFH";
 }
 
 int RenderFrameHostImpl::GetRoutingID() {
   return routing_id_;
 }
 
 SiteInstanceImpl* RenderFrameHostImpl::GetSiteInstance() {
   return site_instance_.get();
 }
 
@@ skipping 361 matching lines @@
 
   return manager->GetFromID(parent_node_id);
 }
 
 bool RenderFrameHostImpl::CreateRenderFrame(int parent_routing_id,
                                             int previous_sibling_routing_id,
                                             int proxy_routing_id) {
   TRACE_EVENT0("navigation", "RenderFrameHostImpl::CreateRenderFrame");
   DCHECK(!IsRenderFrameLive()) << "Creating frame twice";
 
+  LOG(ERROR) << "RFH[" << this << "]::CreateRenderFrame:"
+    << " routing_id:" << routing_id_
+    << " parent:" << parent_routing_id
+    << " previous_sibling_routing_id:" << previous_sibling_routing_id
+    << " proxy:" << proxy_routing_id;
+
   // The process may (if we're sharing a process with another host that already
   // initialized it) or may not (we have our own process or the old process
   // crashed) have been initialized. Calling Init multiple times will be
   // ignored, so this is safe.
   if (!GetProcess()->Init())
     return false;
 
   DCHECK(GetProcess()->HasConnection());
 
   FrameMsg_NewFrame_Params params;
@@ skipping 36 matching lines @@
   // The renderer now has a RenderFrame for this RenderFrameHost.  Note that
   // this path is only used for out-of-process iframes.  Main frame RenderFrames
   // are created with their RenderView, and same-site iframes are created at the
   // time of OnCreateChildFrame.
   SetRenderFrameCreated(true);
 
   return true;
 }
 
 void RenderFrameHostImpl::SetRenderFrameCreated(bool created) {
+  LOG(ERROR) << "RFH[" << this << "]::SetRFCreated: "
+    << created;
   bool was_created = render_frame_created_;
   render_frame_created_ = created;
 
   // If the current status is different than the new status, the delegate
   // needs to be notified.
   if (delegate_ && (created != was_created)) {
     if (created)
       delegate_->RenderFrameCreated(this);
     else
       delegate_->RenderFrameDeleted(this);
@@ skipping 81 matching lines @@
                                base::TimeTicks::Now() - ui_timestamp,
                                base::TimeDelta::FromMilliseconds(10),
                                base::TimeDelta::FromMinutes(10), 100);
   }
   // This message is only sent for top-level frames. TODO(avi): when frame tree
   // mirroring works correctly, add a check here to enforce it.
   delegate_->DocumentOnLoadCompleted(this);
 }
 
 void RenderFrameHostImpl::OnDidStartProvisionalLoadForFrame(const GURL& url) {
+  LOG(ERROR) << "RFH[" << this << "]::DidStartProvLoad:"
+    << " url:" << url;
   frame_tree_node_->navigator()->DidStartProvisionalLoad(
       this, url);
 }
 
 void RenderFrameHostImpl::OnDidFailProvisionalLoadWithError(
     const FrameHostMsg_DidFailProvisionalLoadWithError_Params& params) {
   frame_tree_node_->navigator()->DidFailProvisionalLoadWithError(this, params);
 }
 
 void RenderFrameHostImpl::OnDidFailLoadWithError(
@@ skipping 40 matching lines @@
   // navigating already and sent it before hearing the FrameMsg_Stop message.
   // Treat this as an implicit beforeunload ack to allow the pending navigation
   // to continue.
   if (is_waiting_for_beforeunload_ack_ &&
       unload_ack_is_for_navigation_ &&
       !GetParent()) {
     base::TimeTicks approx_renderer_start_time = send_before_unload_start_time_;
     OnBeforeUnloadACK(true, approx_renderer_start_time, base::TimeTicks::Now());
   }
 
+  LOG(ERROR) << "RFH[" << this << "]::DidCommitProvLoad:"
+    << " url:" << validated_params.url;
+
   // If we're waiting for an unload ack from this renderer and we receive a
   // Navigate message, then the renderer was navigating before it received the
   // unload request.  It will either respond to the unload request soon or our
   // timer will expire.  Either way, we should ignore this message, because we
   // have already committed to closing this renderer.
   if (IsWaitingForUnloadACK())
     return;
 
   if (validated_params.report_type ==
       FrameMsg_UILoadMetricsReportType::REPORT_LINK) {
@@ skipping 627 matching lines @@
     delegate_->EnterFullscreenMode(GetLastCommittedURL().GetOrigin());
   else
     delegate_->ExitFullscreenMode();
 
   // The previous call might change the fullscreen state. We need to make sure
   // the renderer is aware of that, which is done via the resize message.
   render_view_host_->WasResized();
 }
 
 void RenderFrameHostImpl::OnDidStartLoading(bool to_different_document) {
+  LOG(ERROR) << "RFH[" << this << "]::OnDidStartLoading";
   // Any main frame load to a new document should reset the load since it will
   // replace the current page and any frames.
   if (to_different_document && !GetParent())
     is_loading_ = false;
 
   // This method should never be called when the frame is loading.
   // Unfortunately, it can happen if a history navigation happens during a
   // BeforeUnload or Unload event.
   // TODO(fdegans): Change this to a DCHECK after LoadEventProgress has been
   // refactored in Blink. See crbug.com/466089
   if (is_loading_) {
     LOG(WARNING) << "OnDidStartLoading was called twice.";
     return;
   }
 
   frame_tree_node_->DidStartLoading(to_different_document);
   is_loading_ = true;
 }
 
 void RenderFrameHostImpl::OnDidStopLoading() {
+  LOG(ERROR) << "RFH[" << this << "]::OnDidStopLoading";
   // This method should never be called when the frame is not loading.
   // Unfortunately, it can happen if a history navigation happens during a
   // BeforeUnload or Unload event.
   // TODO(fdegans): Change this to a DCHECK after LoadEventProgress has been
   // refactored in Blink. See crbug.com/466089
   if (!is_loading_) {
-    LOG(WARNING) << "OnDidStopLoading was called twice.";
+    LOG(ERROR) << "!!!---!!! OnDidStopLoading was called twice.";
     return;
   }
 
   is_loading_ = false;
   frame_tree_node_->DidStopLoading();
 }
 
 void RenderFrameHostImpl::OnDidChangeLoadProgress(double load_progress) {
   frame_tree_node_->DidChangeLoadProgress(load_progress);
 }
@@ skipping 457 matching lines @@
 
 void RenderFrameHostImpl::InsertVisualStateCallback(
     const VisualStateCallback& callback) {
   static uint64 next_id = 1;
   uint64 key = next_id++;
   Send(new FrameMsg_VisualStateRequest(routing_id_, key));
   visual_state_callbacks_.insert(std::make_pair(key, callback));
 }
 
 bool RenderFrameHostImpl::IsRenderFrameLive() {
+  LOG(ERROR) << "RFH[" << this << "]::IsRenderFrameLive:"
+    << " render_frame_created_:" << render_frame_created_
+    << " process has connection:" << GetProcess()->HasConnection();
   bool is_live = GetProcess()->HasConnection() && render_frame_created_;
 
   // Sanity check: the RenderView should always be live if the RenderFrame is.
   DCHECK_IMPLIES(is_live, render_view_host_->IsRenderViewLive());
 
   return is_live;
 }
 
 #if defined(OS_WIN)
 
@@ skipping 109 matching lines @@
   // We may be returning to an existing NavigationEntry that had been granted
   // file access.  If this is a different process, we will need to grant the
   // access again.  The files listed in the page state are validated when they
   // are received from the renderer to prevent abuse.
   if (request_params.page_state.IsValid()) {
     render_view_host_->GrantFileAccessFromPageState(request_params.page_state);
   }
 }
 
 }  // namespace content