OOPIF: report both original and destination rfh in AboutToNavigateRenderFrame.

content/browser/devtools/render_view_devtools_agent_host.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/devtools/render_view_devtools_agent_host.h"
 
 #include "base/basictypes.h"
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 26 matching lines @@
 #include "content/public/browser/render_widget_host_view.h"
 #endif
 
 namespace content {
 
 typedef std::vector<RenderViewDevToolsAgentHost*> Instances;
 
 namespace {
 base::LazyInstance<Instances>::Leaky g_instances = LAZY_INSTANCE_INITIALIZER;
 
+static RenderViewDevToolsAgentHost* FindAgentHost(RenderFrameHost* host) {
+  if (g_instances == NULL)
+    return NULL;
+  for (Instances::iterator it = g_instances.Get().begin();
+       it != g_instances.Get().end(); ++it) {
+    if ((*it)->HasRenderFrameHost(host))
+      return *it;
+  }
+  return NULL;
+}
+
 // Returns RenderViewDevToolsAgentHost attached to any of RenderFrameHost
 // instances associated with |web_contents|
 static RenderViewDevToolsAgentHost* FindAgentHost(WebContents* web_contents) {
   if (g_instances == NULL)
     return NULL;
   for (Instances::iterator it = g_instances.Get().begin();
        it != g_instances.Get().end(); ++it) {
     if ((*it)->GetWebContents() == web_contents)
       return *it;
   }
@@ skipping 40 matching lines @@
   }
   std::vector<WebContents*> result(set.size());
   std::copy(set.begin(), set.end(), result.begin());
   return result;
 }
 
 // static
 void RenderViewDevToolsAgentHost::OnCancelPendingNavigation(
     RenderFrameHost* pending,
     RenderFrameHost* current) {
-  if (current->GetParent())
-    return;
-  WebContents* web_contents =
-      WebContents::FromRenderFrameHost(pending);
-  RenderViewDevToolsAgentHost* agent_host = FindAgentHost(web_contents);
+  RenderViewDevToolsAgentHost* agent_host = FindAgentHost(pending);
   if (!agent_host)
     return;
   agent_host->DisconnectRenderFrameHost();
   agent_host->ConnectRenderFrameHost(current);
 }
 
 RenderViewDevToolsAgentHost::RenderViewDevToolsAgentHost(RenderFrameHost* rfh)
     : render_frame_host_(NULL),
       dom_handler_(new devtools::dom::DOMHandler()),
       input_handler_(new devtools::input::InputHandler()),
@@ skipping 138 matching lines @@
 RenderViewDevToolsAgentHost::~RenderViewDevToolsAgentHost() {
   Instances::iterator it = std::find(g_instances.Get().begin(),
                                      g_instances.Get().end(),
                                      this);
   if (it != g_instances.Get().end())
     g_instances.Get().erase(it);
 }
 
 // TODO(creis): Consider removing this in favor of RenderFrameHostChanged.
 void RenderViewDevToolsAgentHost::AboutToNavigateRenderFrame(
-    RenderFrameHost* render_frame_host) {
-  if (!render_frame_host_)
-    return;
-  if (render_frame_host->GetParent())
+    RenderFrameHost* old_host,
+    RenderFrameHost* new_host) {
+  if (render_frame_host_ != old_host)
     return;
 
   // TODO(creis): This will need to be updated for --site-per-process, since
   // RenderViewHost is going away and navigations could happen in any frame.
-  if (render_frame_host_ == render_frame_host) {
+  if (render_frame_host_ == new_host) {
     RenderViewHostImpl* rvh = static_cast<RenderViewHostImpl*>(
         render_frame_host_->GetRenderViewHost());
     if (rvh->render_view_termination_status() ==
             base::TERMINATION_STATUS_STILL_RUNNING)
       return;
   }
-  ReattachToRenderFrameHost(render_frame_host);
+  ReattachToRenderFrameHost(new_host);
 }
 
 void RenderViewDevToolsAgentHost::RenderFrameHostChanged(
     RenderFrameHost* old_host,
     RenderFrameHost* new_host) {
-  if (new_host->GetParent())
-    return;
-  if (new_host != render_frame_host_) {
+  if (old_host == render_frame_host_ && new_host != render_frame_host_) {
     // AboutToNavigateRenderFrame was not called for renderer-initiated
     // navigation.
     ReattachToRenderFrameHost(new_host);
   }
 }
 
 void
 RenderViewDevToolsAgentHost::ReattachToRenderFrameHost(RenderFrameHost* rfh) {
   DCHECK(!reattaching_);
   reattaching_ = true;
@@ skipping 87 matching lines @@
                                           const NotificationSource& source,
                                           const NotificationDetails& details) {
   if (type == content::NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED) {
     bool visible = *Details<bool>(details).ptr();
     page_handler_->OnVisibilityChanged(visible);
   }
 }
 
 void RenderViewDevToolsAgentHost::SetRenderFrameHost(RenderFrameHost* rfh) {
   DCHECK(!render_frame_host_);
-  DCHECK(!rfh->GetParent());
   render_frame_host_ = static_cast<RenderFrameHostImpl*>(rfh);
 
   WebContentsObserver::Observe(WebContents::FromRenderFrameHost(rfh));
   RenderViewHostImpl* rvh = static_cast<RenderViewHostImpl*>(
       rfh->GetRenderViewHost());
   dom_handler_->SetRenderViewHost(rvh);
   input_handler_->SetRenderViewHost(rvh);
   network_handler_->SetRenderViewHost(rvh);
   page_handler_->SetRenderViewHost(rvh);
 
@@ skipping 82 matching lines @@
   page_handler_->OnSwapCompositorFrame(get<1>(param).metadata);
 }
 
 void RenderViewDevToolsAgentHost::SynchronousSwapCompositorFrame(
     const cc::CompositorFrameMetadata& frame_metadata) {
   if (!render_frame_host_)
     return;
   page_handler_->OnSwapCompositorFrame(frame_metadata);
 }
 
+bool RenderViewDevToolsAgentHost::HasRenderFrameHost(
+    RenderFrameHost* host) {
+  return host == render_frame_host_;
+}
+
 void RenderViewDevToolsAgentHost::OnDispatchOnInspectorFrontend(
     const DevToolsMessageChunk& message) {
   if (!IsAttached() || !render_frame_host_)
     return;
   ProcessChunkedMessageFromAgent(message);
 }
 
 void RenderViewDevToolsAgentHost::DispatchOnInspectorFrontend(
     const std::string& message) {
   if (!IsAttached() || !render_frame_host_)
     return;
   SendMessageToClient(message);
 }
 
 }  // namespace content