Allow devtools clients to handle slow cross-process navigations.

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/command_line.h"
+#include "base/json/json_reader.h"
 #include "base/lazy_instance.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/values.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"
@@ skipping 71 matching lines @@
   void Reattach(FrameHostHolder* old);
   void Detach();
   void DispatchProtocolMessage(int session_id,
                                int call_id,
                                const std::string& message);
   void InspectElement(int x, int y);
   void ProcessChunkedMessageFromAgent(const DevToolsMessageChunk& chunk);
   void Suspend();
   void Resume();
 
+  bool suspended() const { return suspended_; }
+  const std::string& last_loading_frame_id() const {
+    return last_loading_frame_id_;
+  }
+
  private:
   void GrantPolicy();
   void RevokePolicy();
   void SendMessageToClient(int session_id, const std::string& message);
 
   RenderFrameDevToolsAgentHost* agent_;
   RenderFrameHostImpl* host_;
   bool attached_;
   bool suspended_;
   DevToolsMessageChunkProcessor chunk_processor_;
   // <session_id, message>
   std::vector<std::pair<int, std::string>> pending_messages_;
   // <call_id> -> <session_id, message>
   std::map<int, std::pair<int, std::string>> sent_messages_;
+  std::string last_loading_frame_id_;
 };
 
 RenderFrameDevToolsAgentHost::FrameHostHolder::FrameHostHolder(
     RenderFrameDevToolsAgentHost* agent, RenderFrameHostImpl* host)
     : agent_(agent),
       host_(host),
       attached_(false),
       suspended_(false),
       chunk_processor_(base::Bind(
            &RenderFrameDevToolsAgentHost::FrameHostHolder::SendMessageToClient,
@@ skipping 87 matching lines @@
 }
 
 void RenderFrameDevToolsAgentHost::FrameHostHolder::SendMessageToClient(
     int session_id,
     const std::string& message) {
   sent_messages_.erase(chunk_processor_.last_call_id());
   if (suspended_)
     pending_messages_.push_back(std::make_pair(session_id, message));
   else
     agent_->SendMessageToClient(session_id, message);
+
+  // Store frameId when the frame starts loading to use it in case if the
+  // pending frame host is discarded.
+  if (last_loading_frame_id_.empty() &&
+      message.find("Page.frameStartedLoading") != std::string::npos) {
+    scoped_ptr<base::Value> message_content = base::JSONReader::Read(message);
+    base::DictionaryValue* message_dict;
+    if (message_content && message_content->GetAsDictionary(&message_dict)) {
+      base::DictionaryValue* params;
+      if (message_dict->GetDictionary("params", &params))
+        params->GetString("frameId", &last_loading_frame_id_);
+    }
+  }
 }
 
 void RenderFrameDevToolsAgentHost::FrameHostHolder::Suspend() {
   suspended_ = true;
 }
 
 void RenderFrameDevToolsAgentHost::FrameHostHolder::Resume() {
   suspended_ = false;
   for (const auto& pair : pending_messages_)
     agent_->SendMessageToClient(pair.first, pair.second);
@@ skipping 150 matching lines @@
 void RenderFrameDevToolsAgentHost::SetPending(RenderFrameHostImpl* host) {
   DCHECK(!pending_);
   current_frame_crashed_ = false;
   pending_.reset(new FrameHostHolder(this, host));
   if (IsAttached())
     pending_->Reattach(current_.get());
 
   // Can only be null in constructor.
   if (current_)
     current_->Suspend();
-  pending_->Suspend();
+  // Don't suspend pending_ as it may break clients.
 
   UpdateProtocolHandlers(host);
 }
 
 void RenderFrameDevToolsAgentHost::CommitPending() {
   DCHECK(pending_);
   current_frame_crashed_ = false;
 
   if (!ShouldCreateDevToolsFor(pending_->host())) {
     DestroyOnRenderFrameGone();
@@ skipping 313 matching lines @@
 }
 
 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 (browser_side_navigation)
     return;
-  if (pending_ && pending_->host() == render_frame_host)
+  if (pending_ && pending_->host() == render_frame_host) {
+    // When a pending cross-process navigation gets cancelled, the client does
+    // not receive frameStoppedLoading event, which can cause problems with
+    // further operation. Forge the event to avoid that.
+    if (!pending_->suspended() && !pending_->last_loading_frame_id().empty()) {
+      SendMessageToClient(
+          session_id(),
+          "{\"method\":\"Page.frameStoppedLoading\",\"params\":"
+          "{\"frameId\":\"" + pending_->last_loading_frame_id() + "\"}}");
+    }
+
     DiscardPending();
+  }
 }
 
 void RenderFrameDevToolsAgentHost::
     DispatchBufferedProtocolMessagesIfNecessary() {
   if (in_navigation_ == 0 && in_navigation_protocol_message_buffer_.size()) {
     DCHECK(current_);
     for (const auto& pair : in_navigation_protocol_message_buffer_) {
       current_->DispatchProtocolMessage(pair.second.first, pair.first,
                                         pair.second.second);
     }
@@ skipping 124 matching lines @@
 }
 
 bool RenderFrameDevToolsAgentHost::MatchesMyTreeNode(
     NavigationHandle* navigation_handle) {
   return frame_tree_node_ ==
          static_cast<NavigationHandleImpl*>(navigation_handle)
              ->frame_tree_node();
 }
 
 }  // namespace content