Fix WCO::RenderFrameCreated and WCO::RenderFrameDeleted notifications.

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 137 matching lines @@
       has_unload_handlers_(false),
       override_sudden_termination_status_(false),
       is_waiting_for_beforeunload_ack_(false),
       unload_ack_is_for_navigation_(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);
+
+  LOG(ERROR) << "RFH[" << this << "]::RFH: "
+    << "(" << GetProcess()->GetID() << ", " << GetRoutingID() << ")"
+    << " swapped_out:" << is_swapped_out;
+
   frame_tree_->RegisterRenderFrameHost(this);
   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();
   }
 
   SetUpMojoIfNeeded();
   swapout_event_monitor_timeout_.reset(new TimeoutMonitor(base::Bind(
       &RenderFrameHostImpl::OnSwappedOut, weak_ptr_factory_.GetWeakPtr())));
 
   if (flags & CREATE_RF_NEEDS_RENDER_WIDGET_HOST) {
     render_widget_host_.reset(new RenderWidgetHostImpl(
         rwh_delegate, GetProcess(), MSG_ROUTING_NONE, hidden));
     render_widget_host_->set_owned_by_render_frame_host(true);
   }
 }
 
 RenderFrameHostImpl::~RenderFrameHostImpl() {
   GetProcess()->RemoveRoute(routing_id_);
   g_routing_id_frame_map.Get().erase(
       RenderFrameHostID(GetProcess()->GetID(), routing_id_));
 
-  if (delegate_)
+  // Notify the FrameTree that this RFH is going away, allowing it to shut down
+  // the corresponding RenderViewHost if it is no longer needed.
+  frame_tree_->UnregisterRenderFrameHost(this);
+
+  if (delegate_ && render_frame_created_)
     delegate_->RenderFrameDeleted(this);
 
   FrameAccessibility::GetInstance()->OnRenderFrameHostDestroyed(this);
 
   // If this was swapped out, it already decremented the active frame count of
   // the SiteInstance it belongs to.
   if (IsRFHStateActive(rfh_state_))
     GetSiteInstance()->decrement_active_frame_count();
 
-  // Notify the FrameTree that this RFH is going away, allowing it to shut down
-  // the corresponding RenderViewHost if it is no longer needed.
-  frame_tree_->UnregisterRenderFrameHost(this);
-
   // NULL out the swapout timer; in crash dumps this member will be null only if
   // the dtor has run.
   swapout_event_monitor_timeout_.reset();
 
   for (const auto& iter: flush_visual_state_callbacks_) {
     iter.second.Run(false);
   }
 
   if (render_widget_host_)
     render_widget_host_->Cleanup();
+
+  LOG(ERROR) << "RFH[" << this << "]::~RFH: ";
 }
 
 int RenderFrameHostImpl::GetRoutingID() {
   return routing_id_;
 }
 
 SiteInstanceImpl* RenderFrameHostImpl::GetSiteInstance() {
   return site_instance_.get();
 }
 
@@ skipping 96 matching lines @@
       if (msg.is_sync()) {
         IPC::Message* reply = IPC::SyncMessage::GenerateReply(&msg);
         reply->set_reply_error();
         Send(reply);
       }
       // Don't continue looking for someone to handle it.
       return true;
     }
   }
 
+
   if (delegate_->OnMessageReceived(this, msg))
     return true;
 
   RenderFrameProxyHost* proxy =
       frame_tree_node_->render_manager()->GetProxyToParent();
   if (proxy && proxy->cross_process_frame_connector() &&
       proxy->cross_process_frame_connector()->OnMessageReceived(msg))
     return true;
 
   bool handled = true;
@@ skipping 231 matching lines @@
     widget_params.surface_id = render_widget_host_->surface_id();
     widget_params.hidden = render_widget_host_->is_hidden();
   } else {
     // MSG_ROUTING_NONE will prevent a new RenderWidget from being created in
     // the renderer process.
     widget_params.routing_id = MSG_ROUTING_NONE;
     widget_params.surface_id = 0;
     widget_params.hidden = true;
   }
 
+  LOG(ERROR) << "RFH[" << this << "]::CreateRenderFrame:"
+    << " sending IPC to create RenderFrame";
+
   Send(new FrameMsg_NewFrame(routing_id_, parent_routing_id, proxy_routing_id,
                              frame_tree_node()->current_replication_state(),
                              widget_params));
 
   // The RenderWidgetHost takes ownership of its view. It is tied to the
   // lifetime of the current RenderProcessHost for this RenderFrameHost.
   if (render_widget_host_) {
     RenderWidgetHostView* rwhv =
         new RenderWidgetHostViewChildFrame(render_widget_host_.get());
     rwhv->Hide();
@@ skipping 24 matching lines @@
       render_view_host_->IsRenderViewLive() :
       GetProcess()->HasConnection() && render_frame_created_;
 
   // Sanity check: the RenderView should always be live if the RenderFrame is.
   DCHECK(!is_live || render_view_host_->IsRenderViewLive());
 
   return is_live;
 }
 
 void RenderFrameHostImpl::SetRenderFrameCreated(bool created) {
+  // If the current status is different than the new status, the delegate
+  // needs to be notified.
+  LOG(ERROR) << "RFH[" << this << "]::SetRenderFrameCreated: "
+      << " render_frame_created_:" << render_frame_created_
+      << " created:" << created;
+
+  if (delegate_ && created ^ render_frame_created_) {
+    if (created)
+      delegate_->RenderFrameCreated(this);
+    else
+      delegate_->RenderFrameDeleted(this);
+  }
+
   render_frame_created_ = created;
   if (created && render_widget_host_)
     render_widget_host_->InitForFrame();
 }
 
 void RenderFrameHostImpl::Init() {
   GetProcess()->ResumeRequestsForView(routing_id_);
 }
 
 void RenderFrameHostImpl::OnAddMessageToConsole(
@@ skipping 19 matching lines @@
 void RenderFrameHostImpl::OnCreateChildFrame(int new_routing_id,
                                              const std::string& frame_name,
                                              SandboxFlags sandbox_flags) {
   // It is possible that while a new RenderFrameHost was committed, the
   // RenderFrame corresponding to this host sent an IPC message to create a
   // frame and it is delivered after this host is swapped out.
   // Ignore such messages, as we know this RenderFrameHost is going away.
   if (rfh_state_ != RenderFrameHostImpl::STATE_DEFAULT)
     return;
 
+  LOG(ERROR) << "RFH[" << this << "]::OnCreateChildFrame: "
+      << " new frame: ("
+      << GetProcess()->GetID() << ", " << new_routing_id
+      << ")";
+
   RenderFrameHostImpl* new_frame = frame_tree_->AddFrame(
       frame_tree_node_, GetProcess()->GetID(), new_routing_id, frame_name);
   if (!new_frame)
     return;
 
+  new_frame->frame_tree_node()->set_sandbox_flags(sandbox_flags);
+
   // We know that the RenderFrame has been created in this case, immediately
   // after the CreateChildFrame IPC was sent.
   new_frame->SetRenderFrameCreated(true);
-
-  new_frame->frame_tree_node()->set_sandbox_flags(sandbox_flags);
-
-  if (delegate_)
-    delegate_->RenderFrameCreated(new_frame);
 }
 
 void RenderFrameHostImpl::OnDetach() {
   frame_tree_->RemoveFrame(frame_tree_node_);
 }
 
 void RenderFrameHostImpl::OnFrameFocused() {
   frame_tree_->SetFocusedFrame(frame_tree_node_);
 }
 
@@ skipping 345 matching lines @@
 bool RenderFrameHostImpl::SuddenTerminationAllowed() const {
   return override_sudden_termination_status_ ||
       (!has_beforeunload_handlers_ && !has_unload_handlers_);
 }
 
 void RenderFrameHostImpl::OnSwapOutACK() {
   OnSwappedOut();
 }
 
 void RenderFrameHostImpl::OnRenderProcessGone(int status, int exit_code) {
+  LOG(ERROR) << "RFH[" << this << "]::OnRenderProcessGone: "
+    << " main_frame:" << frame_tree_node_->IsMainFrame()
+    << " created:" << render_frame_created_;
+
   if (frame_tree_node_->IsMainFrame()) {
     // Keep the termination status so we can get at it later when we
     // need to know why it died.
     render_view_host_->render_view_termination_status_ =
         static_cast<base::TerminationStatus>(status);
   }
 
-  SetRenderFrameCreated(false);
-  InvalidateMojoConnection();
-
   // Reset frame tree state associated with this process.  This must happen
   // before RenderViewTerminated because observers expect the subframes of any
   // affected frames to be cleared first.
   // Note: When a RenderFrameHost is swapped out there is a different one
   // which is the current host. In this case, the FrameTreeNode state must
   // not be reset.
   if (!is_swapped_out())
     frame_tree_node_->ResetForNewProcess();
 
+  SetRenderFrameCreated(false);
+  InvalidateMojoConnection();
+
   if (frame_tree_node_->IsMainFrame()) {
     // RenderViewHost/RenderWidgetHost needs to reset some stuff.
     render_view_host_->RendererExited(
         render_view_host_->render_view_termination_status_, exit_code);
 
     render_view_host_->delegate_->RenderViewTerminated(
         render_view_host_, static_cast<base::TerminationStatus>(status),
         exit_code);
   }
 }
@@ skipping 811 matching lines @@
 void RenderFrameHostImpl::DidUseGeolocationPermission() {
   RenderFrameHost* top_frame = frame_tree_node()->frame_tree()->GetMainFrame();
   GetContentClient()->browser()->RegisterPermissionUsage(
       PERMISSION_GEOLOCATION,
       delegate_->GetAsWebContents(),
       GetLastCommittedURL().GetOrigin(),
       top_frame->GetLastCommittedURL().GetOrigin());
 }
 
 }  // namespace content