Issue AboutToNavigateRenderFrame notification after beforeunload handling.

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 20 matching lines @@
 const char kParamsParam[] = "params";
 
 }
 
 class DevToolsProtocolTest : public ContentBrowserTest,
                              public DevToolsAgentHostClient {
  public:
   DevToolsProtocolTest()
       : last_sent_id_(0),
         waiting_for_notifications_count_(0),
-        in_dispatch_(false) {
+        in_dispatch_(false),
+        waiting_for_command_result_id_(0) {

[Charlie Reis, 2015/09/22 23:12:10]

What are these test changes?  I don't see a test for the actual bug, and I'm not
sure how these changes are related to the AboutToNavigateRenderFrame change.

[dgozman, 2015/09/22 23:27:55]

This is a side-effect of different timings between synchronous calls (one of
them is AboutToNavigateRenderFrame). We just happened to be lucky and waited for
the first command ack, instead of the asked one. Now this properly waits for the
actual command we were asked to wait for.

[Charlie Reis, 2015/09/22 23:56:42]

Ok, thanks.  It'd probably be worthwhile to include a test for the change once
we settle on the right approach, if possible.

   }
 
  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 43 matching lines @@
                                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();
       }
     }
   }
 
   void AgentHostClosed(DevToolsAgentHost* agent_host, bool replaced) override {
     EXPECT_TRUE(false);
   }
 
   int waiting_for_notifications_count_;
   bool in_dispatch_;
+  int waiting_for_command_result_id_;
 };
 
 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());
     params->SetString("type", type);
@@ skipping 230 matching lines @@
 
   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);
 }
 
 }  // namespace content