RenderFrameDevToolsAgentHost uses new navigation observer API.

content/browser/devtools/render_frame_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_frame_devtools_agent_host.h"
 
 #include "base/basictypes.h"
 #include "base/lazy_instance.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/devtools/devtools_frame_trace_recorder.h"
 #include "content/browser/devtools/devtools_protocol_handler.h"
 #include "content/browser/devtools/protocol/dom_handler.h"
 #include "content/browser/devtools/protocol/emulation_handler.h"
 #include "content/browser/devtools/protocol/input_handler.h"
 #include "content/browser/devtools/protocol/inspector_handler.h"
 #include "content/browser/devtools/protocol/io_handler.h"
 #include "content/browser/devtools/protocol/network_handler.h"
 #include "content/browser/devtools/protocol/page_handler.h"
 #include "content/browser/devtools/protocol/security_handler.h"
 #include "content/browser/devtools/protocol/service_worker_handler.h"
 #include "content/browser/devtools/protocol/tracing_handler.h"
+#include "content/browser/frame_host/navigation_handle_impl.h"
 #include "content/browser/frame_host/render_frame_host_impl.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/site_instance_impl.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/render_widget_host_iterator.h"
 #include "content/public/browser/web_contents_delegate.h"
@@ skipping 191 matching lines @@
 void RenderFrameDevToolsAgentHost::FrameHostHolder::Resume() {
   suspended_ = false;
   for (const auto& pair : pending_messages_)
     agent_->SendMessageToClient(pair.first, pair.second);
   std::vector<std::pair<int, std::string>> empty;
   pending_messages_.swap(empty);
 }
 
 // RenderFrameDevToolsAgentHost ------------------------------------------------
 
+// static
 scoped_refptr<DevToolsAgentHost>
 DevToolsAgentHost::GetOrCreateFor(RenderFrameHost* frame_host) {
   while (frame_host && !ShouldCreateDevToolsFor(frame_host))
     frame_host = frame_host->GetParent();
   DCHECK(frame_host);
   RenderFrameDevToolsAgentHost* result = FindAgentHost(frame_host);
   if (!result) {
     result = new RenderFrameDevToolsAgentHost(
         static_cast<RenderFrameHostImpl*>(frame_host));
   }
   return result;
 }
 
+// static
 scoped_refptr<DevToolsAgentHost>
 DevToolsAgentHost::GetOrCreateFor(WebContents* web_contents) {
   RenderFrameDevToolsAgentHost* result = FindAgentHost(web_contents);
   if (!result) {
     // TODO(dgozman): this check should not be necessary. See
     // http://crbug.com/489664.
     if (!web_contents->GetMainFrame())
       return nullptr;
     result = new RenderFrameDevToolsAgentHost(
         static_cast<RenderFrameHostImpl*>(web_contents->GetMainFrame()));
@@ skipping 73 matching lines @@
       page_handler_(nullptr),
       security_handler_(nullptr),
       service_worker_handler_(
           new devtools::service_worker::ServiceWorkerHandler()),
       tracing_handler_(new devtools::tracing::TracingHandler(
           devtools::tracing::TracingHandler::Renderer,
           GetIOContext())),
       emulation_handler_(nullptr),
       frame_trace_recorder_(nullptr),
       protocol_handler_(new DevToolsProtocolHandler(this)),
-      current_frame_crashed_(false) {
+      current_frame_crashed_(false),
+      frame_tree_node_(host->frame_tree_node()) {
   DevToolsProtocolDispatcher* dispatcher = protocol_handler_->dispatcher();
   dispatcher->SetDOMHandler(dom_handler_.get());
   dispatcher->SetInputHandler(input_handler_.get());
   dispatcher->SetInspectorHandler(inspector_handler_.get());
   dispatcher->SetIOHandler(io_handler_.get());
   dispatcher->SetNetworkHandler(network_handler_.get());
   dispatcher->SetServiceWorkerHandler(service_worker_handler_.get());
   dispatcher->SetTracingHandler(tracing_handler_.get());
 
   if (!host->GetParent()) {
@@ skipping 135 matching lines @@
 }
 
 RenderFrameDevToolsAgentHost::~RenderFrameDevToolsAgentHost() {
   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);
 }
 
+void RenderFrameDevToolsAgentHost::DidFinishNavigation(
+    NavigationHandle* navigation_handle) {
+  if (MatchesMyTreeNode(navigation_handle) && pending_) {
+    if (navigation_handle->HasCommitted() &&
+        !navigation_handle->IsErrorPage()) {
+      // This was a successful navigation
+      CommitPending();
+      CHECK(current_->host() == navigation_handle->GetRenderFrameHost());
+    } else {
+      // This was an unsuccessful navigation (canceled, failed, interrupted...).
+      DiscardPending();
+    }
+  }
+  service_worker_handler_->UpdateHosts();
+}
+
 void RenderFrameDevToolsAgentHost::AboutToNavigateRenderFrame(
     RenderFrameHost* old_host,
     RenderFrameHost* new_host) {
+  if (!MatchesMyTreeNode(old_host))
+    return;
   DCHECK(!pending_ || pending_->host() != old_host);
-  if (!current_ || current_->host() != old_host)
-    return;
   if (old_host == new_host && !current_frame_crashed_)
     return;
   DCHECK(!pending_);
   SetPending(static_cast<RenderFrameHostImpl*>(new_host));
 }
 
-void RenderFrameDevToolsAgentHost::RenderFrameHostChanged(
-    RenderFrameHost* old_host,
-    RenderFrameHost* new_host) {
-  DCHECK(!pending_ || pending_->host() != old_host);
-  if (!current_ || current_->host() != old_host)
-    return;
+// void RenderFrameDevToolsAgentHost::RenderFrameHostChanged(
+//     RenderFrameHost* old_host,
+//     RenderFrameHost* new_host) {
+//   if (!MatchesMyTreeNode(old_host))
+//     return;
+//   DCHECK(!pending_ || pending_->host() != old_host);
 
-  // AboutToNavigateRenderFrame was not called for renderer-initiated
-  // navigation.
-  if (!pending_)
-    SetPending(static_cast<RenderFrameHostImpl*>(new_host));
+//   // AboutToNavigateRenderFrame was not called for renderer-initiated
+//   // navigation.
+//   if (!pending_) {
+//     SetPending(static_cast<RenderFrameHostImpl*>(new_host));
+//   } else {
+//     DCHECK(pending_->host() == new_host);
+//   }
 
-  CommitPending();
-}
+//   CommitPending();
+// }
 
 void RenderFrameDevToolsAgentHost::FrameDeleted(RenderFrameHost* rfh) {
   if (pending_ && pending_->host() == rfh) {
     DiscardPending();
     return;
   }
 
   if (current_ && current_->host() == rfh)
     DestroyOnRenderFrameGone();  // |this| may be deleted at this point.
 }
 
 void RenderFrameDevToolsAgentHost::RenderFrameDeleted(RenderFrameHost* rfh) {
   if (!current_frame_crashed_)
     FrameDeleted(rfh);
 }
 
 void RenderFrameDevToolsAgentHost::DestroyOnRenderFrameGone() {
   DCHECK(current_);
   scoped_refptr<RenderFrameDevToolsAgentHost> protect(this);
   UpdateProtocolHandlers(nullptr);
   if (IsAttached())
     OnClientDetached();
   HostClosed();
   pending_.reset();
   current_.reset();
+  frame_tree_node_ = nullptr;
+  WebContentsObserver::Observe(nullptr);
   Release();
 }
 
 void RenderFrameDevToolsAgentHost::RenderProcessGone(
     base::TerminationStatus status) {
   switch(status) {
     case base::TERMINATION_STATUS_ABNORMAL_TERMINATION:
     case base::TERMINATION_STATUS_PROCESS_WAS_KILLED:
 #if defined(OS_CHROMEOS)
     case base::TERMINATION_STATUS_PROCESS_WAS_KILLED_BY_OOM:
@@ skipping 54 matching lines @@
   // Pending set in AboutToNavigateRenderFrame turned out to be interstitial.
   // Connect back to the real one.
   DiscardPending();
 }
 
 void RenderFrameDevToolsAgentHost::DidDetachInterstitialPage() {
   if (page_handler_)
     page_handler_->DidDetachInterstitialPage();
 }
 
-void RenderFrameDevToolsAgentHost::DidCommitProvisionalLoadForFrame(
-    RenderFrameHost* render_frame_host,
-    const GURL& url,
-    ui::PageTransition transition_type) {
-  if (pending_ && pending_->host() == render_frame_host)
-    CommitPending();
-  service_worker_handler_->UpdateHosts();
-}
-
-void RenderFrameDevToolsAgentHost::DidFailProvisionalLoad(
-    RenderFrameHost* render_frame_host,
-    const GURL& validated_url,
-    int error_code,
-    const base::string16& error_description,
-    bool was_ignored_by_handler) {
-  if (pending_ && pending_->host() == render_frame_host)
-    DiscardPending();
-}
-
 void RenderFrameDevToolsAgentHost::UpdateProtocolHandlers(
     RenderFrameHostImpl* host) {
   dom_handler_->SetRenderFrameHost(host);
   if (emulation_handler_)
     emulation_handler_->SetRenderFrameHost(host);
   input_handler_->SetRenderWidgetHost(
       host ? host->GetRenderWidgetHost() : nullptr);
   inspector_handler_->SetRenderFrameHost(host);
   network_handler_->SetRenderFrameHost(host);
   if (page_handler_)
     page_handler_->SetRenderFrameHost(host);
   service_worker_handler_->SetRenderFrameHost(host);
   if (security_handler_)
     security_handler_->SetRenderFrameHost(host);
 }
 
 void RenderFrameDevToolsAgentHost::DisconnectWebContents() {
   if (pending_)
     DiscardPending();
   UpdateProtocolHandlers(nullptr);
   disconnected_ = current_.Pass();
   disconnected_->Detach();
+  frame_tree_node_ = nullptr;
   WebContentsObserver::Observe(nullptr);
 }
 
 void RenderFrameDevToolsAgentHost::ConnectWebContents(WebContents* wc) {
   DCHECK(!current_);
   DCHECK(!pending_);
   RenderFrameHostImpl* host =
       static_cast<RenderFrameHostImpl*>(wc->GetMainFrame());
   DCHECK(host);
+  frame_tree_node_ = host->frame_tree_node();
   current_ = disconnected_.Pass();
   SetPending(host);
   CommitPending();
   WebContentsObserver::Observe(WebContents::FromRenderFrameHost(host));
 }
 
 DevToolsAgentHost::Type RenderFrameDevToolsAgentHost::GetType() {
   return IsChildFrame() ? TYPE_FRAME : TYPE_WEB_CONTENTS;
 }
 
@@ skipping 66 matching lines @@
 bool RenderFrameDevToolsAgentHost::HasRenderFrameHost(
     RenderFrameHost* host) {
   return (current_ && current_->host() == host) ||
       (pending_ && pending_->host() == host);
 }
 
 bool RenderFrameDevToolsAgentHost::IsChildFrame() {
   return current_ && current_->host()->GetParent();
 }
 
+bool RenderFrameDevToolsAgentHost::MatchesMyTreeNode(
+    NavigationHandle* navigation_handle) {
+  return frame_tree_node_ ==
+         static_cast<NavigationHandleImpl*>(navigation_handle)
+             ->frame_tree_node();
+}
+
+bool RenderFrameDevToolsAgentHost::MatchesMyTreeNode(
+    RenderFrameHost* render_frame_host) {
+  return frame_tree_node_ ==
+         static_cast<RenderFrameHostImpl*>(render_frame_host)
+             ->frame_tree_node();
+}
+
 }  // namespace content