Disable headless TargetDomain tests on Windows.

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/base_paths.h"
 #include "base/files/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/strings/string_util.h"
 #include "base/threading/thread_restrictions.h"
+#include "build/build_config.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/browser.h"
 #include "headless/public/devtools/domains/dom.h"
 #include "headless/public/devtools/domains/dom_snapshot.h"
 #include "headless/public/devtools/domains/emulation.h"
 #include "headless/public/devtools/domains/inspector.h"
@@ skipping 425 matching lines @@
                    base::Unretained(this)));
   }
 
   void OnCloseTargetResult(std::unique_ptr<target::CloseTargetResult> result) {
     EXPECT_TRUE(result->GetSuccess());
     EXPECT_EQ(1u, GetAllWebContents(browser()).size());
     FinishAsynchronousTest();
   }
 };
 
+#if defined(OS_WIN)
+DISABLED_HEADLESS_ASYNC_DEVTOOLED_TEST_F(TargetDomainCreateAndDeletePageTest);
+#else
 HEADLESS_ASYNC_DEVTOOLED_TEST_F(TargetDomainCreateAndDeletePageTest);
+#endif
 
 class TargetDomainCreateAndDeleteBrowserContextTest
     : public HeadlessAsyncDevTooledBrowserTest {
   void RunDevTooledTest() override {
     EXPECT_TRUE(embedded_test_server()->Start());
 
     EXPECT_EQ(1u, GetAllWebContents(browser()).size());
 
     devtools_client_->GetTarget()->GetExperimental()->CreateBrowserContext(
         target::CreateBrowserContextParams::Builder().Build(),
@@ skipping 47 matching lines @@
   void OnDisposeBrowserContextResult(
       std::unique_ptr<target::DisposeBrowserContextResult> result) {
     EXPECT_TRUE(result->GetSuccess());
     FinishAsynchronousTest();
   }
 
  private:
   std::string browser_context_id_;
 };
 
+#if defined(OS_WIN)
+DISABLED_HEADLESS_ASYNC_DEVTOOLED_TEST_F(
+    TargetDomainCreateAndDeleteBrowserContextTest);
+#else
 HEADLESS_ASYNC_DEVTOOLED_TEST_F(TargetDomainCreateAndDeleteBrowserContextTest);
+#endif
 
 class TargetDomainDisposeContextFailsIfInUse
     : public HeadlessAsyncDevTooledBrowserTest {
   void RunDevTooledTest() override {
     EXPECT_TRUE(embedded_test_server()->Start());
 
     EXPECT_EQ(1u, GetAllWebContents(browser()).size());
     devtools_client_->GetTarget()->GetExperimental()->CreateBrowserContext(
         target::CreateBrowserContextParams::Builder().Build(),
         base::Bind(&TargetDomainDisposeContextFailsIfInUse::OnContextCreated,
@@ skipping 55 matching lines @@
       std::unique_ptr<target::DisposeBrowserContextResult> result) {
     EXPECT_TRUE(result->GetSuccess());
     FinishAsynchronousTest();
   }
 
  private:
   std::string context_id_;
   std::string page_id_;
 };
 
+#if defined(OS_WIN)
+DISABLED_HEADLESS_ASYNC_DEVTOOLED_TEST_F(
+    TargetDomainDisposeContextFailsIfInUse);
+#else
 HEADLESS_ASYNC_DEVTOOLED_TEST_F(TargetDomainDisposeContextFailsIfInUse);
+#endif
 
 class TargetDomainCreateTwoContexts : public HeadlessAsyncDevTooledBrowserTest,
                                       public target::ExperimentalObserver,
                                       public page::Observer {
  public:
   void RunDevTooledTest() override {
     EXPECT_TRUE(embedded_test_server()->Start());
 
     base::RunLoop run_loop;
     devtools_client_->GetPage()->AddObserver(this);
@@ skipping 251 matching lines @@
   std::string context_id_one_;
   std::string context_id_two_;
   std::string page_id_one_;
   std::string page_id_two_;
   bool page_one_loaded_ = false;
   bool page_two_loaded_ = false;
   int page_close_count_ = 0;
   int context_closed_count_ = 0;
 };
 
+#if defined(OS_WIN)
+DISABLED_HEADLESS_ASYNC_DEVTOOLED_TEST_F(TargetDomainCreateTwoContexts);
+#else
 HEADLESS_ASYNC_DEVTOOLED_TEST_F(TargetDomainCreateTwoContexts);
+#endif
 
 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(run_loop.QuitClosure());
@@ skipping 544 matching lines @@
   }
 
  private:
   base::Lock lock_;
   std::string url_that_failed_to_load_;
 };
 
 HEADLESS_ASYNC_DEVTOOLED_TEST_F(FailedUrlRequestTest);
 
 }  // namespace headless