Remove AboutToNavigateRenderFrame, issue custom notification for DevTools.

content/browser/devtools/protocol/devtools_protocol_browsertest.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 "base/base64.h"
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/values.h"
 #include "content/public/browser/devtools_agent_host.h"
@@ skipping 19 matching lines @@
 const char kMethodParam[] = "method";
 const char kParamsParam[] = "params";
 
 }
 
 class DevToolsProtocolTest : public ContentBrowserTest,
                              public DevToolsAgentHostClient {
  public:
   DevToolsProtocolTest()
       : last_sent_id_(0),
-        waiting_for_notifications_count_(0),
+        waiting_for_command_result_id_(0),
         in_dispatch_(false) {
   }
 
  protected:
   void SendCommand(const std::string& method,
                    scoped_ptr<base::DictionaryValue> params) {
     SendCommand(method, params.Pass(), true);
   }
 
   void SendCommand(const std::string& method,
                    scoped_ptr<base::DictionaryValue> params,
                    bool wait) {
     in_dispatch_ = true;
     base::DictionaryValue command;
     command.SetInteger(kIdParam, ++last_sent_id_);
     command.SetString(kMethodParam, method);
     if (params)
       command.Set(kParamsParam, params.release());
 
     std::string json_command;
     base::JSONWriter::Write(command, &json_command);
     agent_host_->DispatchProtocolMessage(json_command);
     // Some messages are dispatched synchronously.
     // Only run loop if we are not finished yet.
-    if (in_dispatch_ && wait)
+    if (in_dispatch_ && wait) {
+      waiting_for_command_result_id_ = last_sent_id_;
       base::MessageLoop::current()->Run();
+    }
     in_dispatch_ = false;
   }
 
   bool HasValue(const std::string& path) {
     base::Value* value = 0;
     return result_->Get(path, &value);
   }
 
   bool HasListItem(const std::string& path_to_list,
                    const std::string& name,
@@ skipping 20 matching lines @@
     agent_host_->AttachClient(this);
   }
 
   void TearDownOnMainThread() override {
     if (agent_host_) {
       agent_host_->DetachClient();
       agent_host_ = nullptr;
     }
   }
 
-  void WaitForNotifications(int count) {
-    waiting_for_notifications_count_ = count;
+  void WaitForNotification(const std::string& notification) {
+    waiting_for_notification_ = notification;
     RunMessageLoop();
   }
 
   scoped_ptr<base::DictionaryValue> result_;
   scoped_refptr<DevToolsAgentHost> agent_host_;
   int last_sent_id_;
   std::vector<int> result_ids_;
   std::vector<std::string> notifications_;
 
  private:
   void DispatchProtocolMessage(DevToolsAgentHost* agent_host,
                                const std::string& message) override {
     scoped_ptr<base::DictionaryValue> root(static_cast<base::DictionaryValue*>(
         base::JSONReader::Read(message).release()));
     int id;
     if (root->GetInteger("id", &id)) {
       result_ids_.push_back(id);
       base::DictionaryValue* result;
       EXPECT_TRUE(root->GetDictionary("result", &result));
       result_.reset(result->DeepCopy());
       in_dispatch_ = false;
-      if (base::MessageLoop::current()->is_running())
+      if (id && id == waiting_for_command_result_id_) {
+        waiting_for_command_result_id_ = 0;
         base::MessageLoop::current()->QuitNow();
+      }
     } else {
       std::string notification;
       EXPECT_TRUE(root->GetString("method", &notification));
       notifications_.push_back(notification);
-      if (waiting_for_notifications_count_) {
-        waiting_for_notifications_count_--;
-        if (!waiting_for_notifications_count_)
-          base::MessageLoop::current()->QuitNow();
+      if (waiting_for_notification_ == notification) {
+        waiting_for_notification_ = std::string();
+        base::MessageLoop::current()->QuitNow();
       }
     }
   }
 
   void AgentHostClosed(DevToolsAgentHost* agent_host, bool replaced) override {
     EXPECT_TRUE(false);
   }
 
-  int waiting_for_notifications_count_;
+  std::string waiting_for_notification_;
+  int waiting_for_command_result_id_;
   bool in_dispatch_;
 };
 
 class SyntheticKeyEventTest : public DevToolsProtocolTest {
  protected:
   void SendKeyEvent(const std::string& type,
                     int modifier,
                     int windowsKeyCode,
                     int nativeKeyCode) {
     scoped_ptr<base::DictionaryValue> params(new base::DictionaryValue());
@@ skipping 217 matching lines @@
   ASSERT_TRUE(test_server()->Start());
   GURL test_url = test_server()->GetURL("files/devtools/navigation.html");
   NavigateToURLBlockUntilNavigationsComplete(shell(), test_url, 1);
 
   Shell* second = CreateBrowser();
   NavigateToURLBlockUntilNavigationsComplete(second, test_url, 1);
 
   Attach();
   SendCommand("Runtime.enable", nullptr);
 
-  size_t notification_count = notifications_.size();
   agent_host_->DisconnectWebContents();
   agent_host_->ConnectWebContents(second->web_contents());
-  WaitForNotifications(1);
+  WaitForNotification("Runtime.executionContextsCleared");
+}
 
-  bool found_notification = false;
-  for (size_t i = notification_count; i < notifications_.size(); ++i) {
-    if (notifications_[i] == "Runtime.executionContextsCleared")
-      found_notification = true;
-  }
-  EXPECT_TRUE(found_notification);
+IN_PROC_BROWSER_TEST_F(DevToolsProtocolTest, CrossSitePauseInBeforeUnload) {
+  host_resolver()->AddRule("*", "127.0.0.1");
+  ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
+  content::SetupCrossSiteRedirector(embedded_test_server());
+
+  NavigateToURLBlockUntilNavigationsComplete(shell(),
+      embedded_test_server()->GetURL("A.com", "/devtools/navigation.html"), 1);
+  Attach();
+  SendCommand("Debugger.enable", nullptr);
+
+  ASSERT_TRUE(content::ExecuteScript(
+      shell()->web_contents(),
+      "window.onbeforeunload = function() { debugger; return null; }"));
+
+  shell()->LoadURL(
+      embedded_test_server()->GetURL("B.com", "/devtools/navigation.html"));
+  WaitForNotification("Debugger.paused");
+  TestNavigationObserver observer(shell()->web_contents(), 1);
+  SendCommand("Debugger.resume", nullptr);
+  observer.Wait();
 }
 
 }  // namespace content