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

content/browser/web_contents/web_contents_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/browser/web_contents/web_contents_impl.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
@@ skipping 345 matching lines @@
       fullscreen_widget_had_focus_at_shutdown_(false),
       is_subframe_(false),
       force_disable_overscroll_content_(false),
       last_dialog_suppressed_(false),
       geolocation_service_context_(new GeolocationServiceContext()),
       accessibility_mode_(
           BrowserAccessibilityStateImpl::GetInstance()->accessibility_mode()),
       audio_stream_monitor_(this),
       virtual_keyboard_requested_(false),
       loading_weak_factory_(this) {
+  LOG(ERROR) << "WC[" << this << "]::WC";
   frame_tree_.SetFrameRemoveListener(
       base::Bind(&WebContentsImpl::OnFrameRemoved,
                  base::Unretained(this)));
 #if defined(ENABLE_BROWSER_CDMS)
   media_web_contents_observer_.reset(new MediaWebContentsObserver(this));
 #endif
 }
 
 WebContentsImpl::~WebContentsImpl() {
   is_being_destroyed_ = true;
@@ skipping 25 matching lines @@
       NOTIFICATION_WEB_CONTENTS_DESTROYED,
       Source<WebContents>(this),
       NotificationService::NoDetails());
 
   // Destroy all frame tree nodes except for the root; this notifies observers.
   frame_tree_.ResetForMainFrameSwap();
   GetRenderManager()->ResetProxyHosts();
 
   // Manually call the observer methods for the root frame tree node.
   RenderFrameHostManager* root = GetRenderManager();
-  if (root->pending_frame_host()) {
-    FOR_EACH_OBSERVER(WebContentsObserver,
-                      observers_,
-                      RenderFrameDeleted(root->pending_frame_host()));
-  }
-  FOR_EACH_OBSERVER(WebContentsObserver,
-                    observers_,
-                    RenderFrameDeleted(root->current_frame_host()));
-
   if (root->pending_render_view_host()) {
     FOR_EACH_OBSERVER(WebContentsObserver,
                       observers_,
                       RenderViewDeleted(root->pending_render_view_host()));
   }
 
   FOR_EACH_OBSERVER(WebContentsObserver,
                     observers_,
                     RenderViewDeleted(root->current_host()));
 
   FOR_EACH_OBSERVER(WebContentsObserver,
                     observers_,
                     WebContentsDestroyed());
 
   FOR_EACH_OBSERVER(WebContentsObserver,
                     observers_,
                     ResetWebContents());
 
   SetDelegate(NULL);
 
   STLDeleteContainerPairSecondPointers(destruction_observers_.begin(),
                                        destruction_observers_.end());
+  LOG(ERROR) << "WC[" << this << "]::~WC";
 }
 
 WebContentsImpl* WebContentsImpl::CreateWithOpener(
     const WebContents::CreateParams& params,
     WebContentsImpl* opener) {
   TRACE_EVENT0("browser", "WebContentsImpl::CreateWithOpener");
   WebContentsImpl* new_contents = new WebContentsImpl(
       params.browser_context, params.opener_suppressed ? NULL : opener);
 
   if (params.guest_delegate) {
@@ skipping 46 matching lines @@
                                         const IPC::Message& message) {
   DCHECK(render_view_host || render_frame_host);
   if (GetWebUI() &&
       static_cast<WebUIImpl*>(GetWebUI())->OnMessageReceived(message)) {
     return true;
   }
 
   ObserverListBase<WebContentsObserver>::Iterator it(observers_);
   WebContentsObserver* observer;
   if (render_frame_host) {
-    while ((observer = it.GetNext()) != NULL)
-      if (observer->OnMessageReceived(message, render_frame_host))
-        return true;
+    if (!static_cast<RenderFrameHostImpl*>(render_frame_host)->is_swapped_out()) {
+      while ((observer = it.GetNext()) != NULL)
+        if (observer->OnMessageReceived(message, render_frame_host))
+          return true;
+    }
   } else {
     while ((observer = it.GetNext()) != NULL)
       if (observer->OnMessageReceived(message))
         return true;
   }
 
   // Message handlers should be aware of which
   // RenderViewHost/RenderFrameHost sent the message, which is temporarily
   // stored in render_(view|frame)_message_source_.
   if (render_frame_host)
@@ skipping 672 matching lines @@
     default:
       NOTREACHED();
   }
 }
 
 WebContents* WebContentsImpl::GetWebContents() {
   return this;
 }
 
 void WebContentsImpl::Init(const WebContents::CreateParams& params) {
+  LOG(ERROR) << "WC[" << this << "]::Init";
+
   // This is set before initializing the render manager since
   // RenderFrameHostManager::Init calls back into us via its delegate to ask if
   // it should be hidden.
   should_normally_be_visible_ = !params.initially_hidden;
 
   // Either both routing ids can be given, or neither can be.
   DCHECK((params.routing_id == MSG_ROUTING_NONE &&
               params.main_frame_routing_id == MSG_ROUTING_NONE) ||
          (params.routing_id != MSG_ROUTING_NONE &&
               params.main_frame_routing_id != MSG_ROUTING_NONE));
@@ skipping 46 matching lines @@
   date_time_chooser_.reset(new DateTimeChooserAndroid());
 #endif
 
   // BrowserPluginGuest::Init needs to be called after this WebContents has
   // a RenderWidgetHostViewGuest. That is, |view_->CreateView| above.
   if (browser_plugin_guest_)
     browser_plugin_guest_->Init();
 
   for (size_t i = 0; i < g_created_callbacks.Get().size(); i++)
     g_created_callbacks.Get().at(i).Run(this);
+
+  NotifySwappedFromRenderManager(
+      nullptr, GetRenderManager()->current_frame_host(), true);
 }
 
 void WebContentsImpl::OnWebContentsDestroyed(WebContentsImpl* web_contents) {
   RemoveDestructionObserver(web_contents);
 
   // Clear the opener if it has been closed.
   if (web_contents == opener_) {
     opener_ = NULL;
     return;
   }
@@ skipping 2313 matching lines @@
 
 void WebContentsImpl::RemoveBrowserPluginEmbedder() {
   if (browser_plugin_embedder_)
     browser_plugin_embedder_.reset();
 }
 
 void WebContentsImpl::RenderViewCreated(RenderViewHost* render_view_host) {
   // Don't send notifications if we are just creating a swapped-out RVH for
   // the opener chain.  These won't be used for view-source or WebUI, so it's
   // ok to return early.
-  if (!static_cast<RenderViewHostImpl*>(render_view_host)->is_active())
-    return;
+  bool rvh_is_active =
+      static_cast<RenderViewHostImpl*>(render_view_host)->is_active();
 
-  if (delegate_)
-    view_->SetOverscrollControllerEnabled(CanOverscrollContent());
+  if (rvh_is_active) {
+    if (delegate_)
+      view_->SetOverscrollControllerEnabled(CanOverscrollContent());
 
-  NotificationService::current()->Notify(
-      NOTIFICATION_WEB_CONTENTS_RENDER_VIEW_HOST_CREATED,
-      Source<WebContents>(this),
-      Details<RenderViewHost>(render_view_host));
+    NotificationService::current()->Notify(
+        NOTIFICATION_WEB_CONTENTS_RENDER_VIEW_HOST_CREATED,
+        Source<WebContents>(this),
+        Details<RenderViewHost>(render_view_host));
 
-  // When we're creating views, we're still doing initial setup, so we always
-  // use the pending Web UI rather than any possibly existing committed one.
-  if (GetRenderManager()->pending_web_ui())
-    GetRenderManager()->pending_web_ui()->RenderViewCreated(render_view_host);
+    // When we're creating views, we're still doing initial setup, so we always
+    // use the pending Web UI rather than any possibly existing committed one.
+    if (GetRenderManager()->pending_web_ui())
+      GetRenderManager()->pending_web_ui()->RenderViewCreated(render_view_host);
 
-  NavigationEntry* entry = controller_.GetPendingEntry();
-  if (entry && entry->IsViewSourceMode()) {
-    // Put the renderer in view source mode.
-    render_view_host->Send(
-        new ViewMsg_EnableViewSourceMode(render_view_host->GetRoutingID()));
+    NavigationEntry* entry = controller_.GetPendingEntry();
+    if (entry && entry->IsViewSourceMode()) {
+      // Put the renderer in view source mode.
+      render_view_host->Send(
+          new ViewMsg_EnableViewSourceMode(render_view_host->GetRoutingID()));
+    }
+
+    view_->RenderViewCreated(render_view_host);
+
+    FOR_EACH_OBSERVER(
+        WebContentsObserver, observers_, RenderViewCreated(render_view_host));
   }
 
-  view_->RenderViewCreated(render_view_host);
+  RenderFrameHostImpl* rfh =
+      static_cast<RenderFrameHostImpl*>(render_view_host->GetMainFrame());
+  rfh->SetRenderFrameCreated(true);
 
-  FOR_EACH_OBSERVER(
-      WebContentsObserver, observers_, RenderViewCreated(render_view_host));
-
-  // We tell the observers now instead of when the main RenderFrameHostImpl is
-  // constructed because otherwise it would be too early (i.e. IPCs sent to the
-  // frame would be dropped because it's not created yet).
-  RenderFrameHost* main_frame = render_view_host->GetMainFrame();
-  FOR_EACH_OBSERVER(
-      WebContentsObserver, observers_, RenderFrameCreated(main_frame));
-  SetAccessibilityModeOnFrame(accessibility_mode_, main_frame);
-
-  DevToolsManager::GetInstance()->RenderViewCreated(this, render_view_host);
+  if (rvh_is_active)
+    DevToolsManager::GetInstance()->RenderViewCreated(this, render_view_host);
 }
 
 void WebContentsImpl::RenderViewReady(RenderViewHost* rvh) {
   if (rvh != GetRenderViewHost()) {
     // Don't notify the world, since this came from a renderer in the
     // background.
     return;
   }
 
   notify_disconnection_ = true;
@@ skipping 12 matching lines @@
       (!delegate_ || delegate_->ShouldFocusPageAfterCrash())) {
     view_->Focus();
   }
 
   FOR_EACH_OBSERVER(WebContentsObserver, observers_, RenderViewReady());
 }
 
 void WebContentsImpl::RenderViewTerminated(RenderViewHost* rvh,
                                            base::TerminationStatus status,
                                            int error_code) {
-  // TODO(nasko): This isn't ideal; the termination process should be handled by
-  // RenderFrameDeleted().  See http://crbug.com/455943.
-  ClearPowerSaveBlockers(rvh->GetMainFrame());
-
   if (rvh != GetRenderViewHost()) {
     // The pending page's RenderViewHost is gone.
     return;
   }
 
   // Ensure fullscreen mode is exited in the |delegate_| since a crashed
   // renderer may not have made a clean exit.
   if (IsFullscreenForCurrentTab())
     ExitFullscreenMode();
 
@@ skipping 791 matching lines @@
   node->render_manager()->ResumeResponseDeferredAtStart();
 }
 
 void WebContentsImpl::SetForceDisableOverscrollContent(bool force_disable) {
   force_disable_overscroll_content_ = force_disable;
   if (view_)
     view_->SetOverscrollControllerEnabled(CanOverscrollContent());
 }
 
 }  // namespace content