Fix headless_browsertests failures with PlzNavigate.

headless/lib/headless_devtools_client_browsertest.cc

 // Copyright 2016 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 <memory>
 
 #include "base/json/json_reader.h"
+#include "base/run_loop.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/test/browser_test.h"
 #include "headless/lib/browser/headless_web_contents_impl.h"
 #include "headless/public/devtools/domains/dom.h"
 #include "headless/public/devtools/domains/emulation.h"
 #include "headless/public/devtools/domains/inspector.h"
 #include "headless/public/devtools/domains/network.h"
 #include "headless/public/devtools/domains/page.h"
@@ skipping 38 matching lines @@
     : public HeadlessAsyncDevTooledBrowserTest,
       page::ExperimentalObserver {
  public:
   void RunDevTooledTest() override {
     EXPECT_TRUE(embedded_test_server()->Start());
     std::unique_ptr<page::NavigateParams> params =
         page::NavigateParams::Builder()
             .SetUrl(embedded_test_server()->GetURL("/hello.html").spec())
             .Build();
     devtools_client_->GetPage()->GetExperimental()->AddObserver(this);
-    devtools_client_->GetPage()->Enable();
+    base::RunLoop run_loop;
+    base::MessageLoop::ScopedNestableTaskAllower nest_loop(
+        base::MessageLoop::current());
+    devtools_client_->GetPage()->Enable(run_loop.QuitClosure());
+    run_loop.Run();
     devtools_client_->GetPage()->Navigate(std::move(params));
   }
 
   void OnLoadEventFired(const page::LoadEventFiredParams& params) override {
     devtools_client_->GetPage()->Disable();
     devtools_client_->GetPage()->GetExperimental()->RemoveObserver(this);
     FinishAsynchronousTest();
   }
 
   // Check that events with no parameters still get a parameters object.
@@ skipping 72 matching lines @@
 };
 
 HEADLESS_ASYNC_DEVTOOLED_TEST_F(HeadlessDevToolsClientCallbackTest);
 
 class HeadlessDevToolsClientObserverTest
     : public HeadlessAsyncDevTooledBrowserTest,
       network::Observer {
  public:
   void RunDevTooledTest() override {
     EXPECT_TRUE(embedded_test_server()->Start());
+    base::RunLoop run_loop;
     devtools_client_->GetNetwork()->AddObserver(this);
-    devtools_client_->GetNetwork()->Enable();
+    devtools_client_->GetNetwork()->Enable(run_loop.QuitClosure());
+    base::MessageLoop::ScopedNestableTaskAllower nest_loop(
+        base::MessageLoop::current());
+    run_loop.Run();
+
     devtools_client_->GetPage()->Navigate(
         embedded_test_server()->GetURL("/hello.html").spec());
   }
 
   void OnRequestWillBeSent(
       const network::RequestWillBeSentParams& params) override {
     EXPECT_EQ("GET", params.GetRequest()->GetMethod());
     EXPECT_EQ(embedded_test_server()->GetURL("/hello.html").spec(),
               params.GetRequest()->GetUrl());
   }
@@ skipping 14 matching lines @@
 };
 
 HEADLESS_ASYNC_DEVTOOLED_TEST_F(HeadlessDevToolsClientObserverTest);
 
 class HeadlessDevToolsClientExperimentalTest
     : public HeadlessAsyncDevTooledBrowserTest,
       page::ExperimentalObserver {
  public:
   void RunDevTooledTest() override {
     EXPECT_TRUE(embedded_test_server()->Start());
+    base::RunLoop run_loop;
+    devtools_client_->GetPage()->GetExperimental()->AddObserver(this);
+    devtools_client_->GetPage()->Enable(run_loop.QuitClosure());
+    base::MessageLoop::ScopedNestableTaskAllower nest_loop(
+        base::MessageLoop::current());
+    run_loop.Run();
     // Check that experimental commands require parameter objects.
     devtools_client_->GetRuntime()
         ->GetExperimental()
         ->SetCustomObjectFormatterEnabled(
             runtime::SetCustomObjectFormatterEnabledParams::Builder()
                 .SetEnabled(false)
                 .Build());
 
     // Check that a previously experimental command which takes no parameters
     // still works by giving it a parameter object.
     devtools_client_->GetRuntime()->GetExperimental()->RunIfWaitingForDebugger(
         runtime::RunIfWaitingForDebuggerParams::Builder().Build());
 
-    devtools_client_->GetPage()->GetExperimental()->AddObserver(this);
-    devtools_client_->GetPage()->Enable();
     devtools_client_->GetPage()->Navigate(
         embedded_test_server()->GetURL("/hello.html").spec());
   }
 
   void OnFrameStoppedLoading(
       const page::FrameStoppedLoadingParams& params) override {
     devtools_client_->GetPage()->Disable();
     devtools_client_->GetPage()->GetExperimental()->RemoveObserver(this);
 
     // Check that a non-experimental command which has no return value can be
@@ skipping 411 matching lines @@
 };
 
 HEADLESS_ASYNC_DEVTOOLED_TEST_F(TargetDomainCreateTwoContexts);
 
 class HeadlessDevToolsNavigationControlTest
     : public HeadlessAsyncDevTooledBrowserTest,
       page::ExperimentalObserver {
  public:
   void RunDevTooledTest() override {
     EXPECT_TRUE(embedded_test_server()->Start());
+    base::RunLoop run_loop;
     devtools_client_->GetPage()->GetExperimental()->AddObserver(this);
-    devtools_client_->GetPage()->Enable();
+    devtools_client_->GetPage()->Enable(run_loop.QuitClosure());
+    base::MessageLoop::ScopedNestableTaskAllower nest_loop(
+        base::MessageLoop::current());
+    run_loop.Run();
     devtools_client_->GetPage()->GetExperimental()->SetControlNavigations(
         headless::page::SetControlNavigationsParams::Builder()
             .SetEnabled(true)
             .Build());
     devtools_client_->GetPage()->Navigate(
         embedded_test_server()->GetURL("/hello.html").spec());
   }
 
   void OnNavigationRequested(
       const headless::page::NavigationRequestedParams& params) override {
@@ skipping 101 matching lines @@
 };
 
 HEADLESS_ASYNC_DEVTOOLED_TEST_F(HeadlessDevToolsClientAttachTest);
 
 class HeadlessDevToolsMethodCallErrorTest
     : public HeadlessAsyncDevTooledBrowserTest,
       public page::Observer {
  public:
   void RunDevTooledTest() override {
     EXPECT_TRUE(embedded_test_server()->Start());
+    base::RunLoop run_loop;
     devtools_client_->GetPage()->AddObserver(this);
-    devtools_client_->GetPage()->Enable();
+    devtools_client_->GetPage()->Enable(run_loop.QuitClosure());
+    base::MessageLoop::ScopedNestableTaskAllower nest_loop(
+        base::MessageLoop::current());
+    run_loop.Run();
     devtools_client_->GetPage()->Navigate(
         embedded_test_server()->GetURL("/hello.html").spec());
   }
 
   void OnLoadEventFired(const page::LoadEventFiredParams& params) override {
     devtools_client_->GetPage()->GetExperimental()->RemoveObserver(this);
     devtools_client_->GetDOM()->GetDocument(
         base::Bind(&HeadlessDevToolsMethodCallErrorTest::OnGetDocument,
                    base::Unretained(this)));
   }
@@ skipping 16 matching lines @@
 
 HEADLESS_ASYNC_DEVTOOLED_TEST_F(HeadlessDevToolsMethodCallErrorTest);
 
 class HeadlessDevToolsNetworkBlockedUrlTest
     : public HeadlessAsyncDevTooledBrowserTest,
       public page::Observer,
       public network::Observer {
  public:
   void RunDevTooledTest() override {
     EXPECT_TRUE(embedded_test_server()->Start());
+    base::RunLoop run_loop;
     devtools_client_->GetPage()->AddObserver(this);
     devtools_client_->GetPage()->Enable();
     devtools_client_->GetNetwork()->AddObserver(this);
-    devtools_client_->GetNetwork()->Enable();
+    devtools_client_->GetNetwork()->Enable(run_loop.QuitClosure());
+    base::MessageLoop::ScopedNestableTaskAllower nest_loop(
+        base::MessageLoop::current());
+    run_loop.Run();
     devtools_client_->GetNetwork()->GetExperimental()->AddBlockedURL(
         network::AddBlockedURLParams::Builder()
             .SetUrl("dom_tree_test.css")
             .Build());
     devtools_client_->GetPage()->Navigate(
         embedded_test_server()->GetURL("/dom_tree_test.html").spec());
   }
 
   std::string GetUrlPath(const std::string& url) const {
     GURL gurl(url);
@@ skipping 29 matching lines @@
 
   std::map<std::string, std::string> request_id_to_path_;
   std::vector<std::string> requests_to_be_sent_;
   std::vector<std::string> responses_received_;
   std::vector<std::string> failures_;
 };
 
 HEADLESS_ASYNC_DEVTOOLED_TEST_F(HeadlessDevToolsNetworkBlockedUrlTest);
 
 }  // namespace headless