Add --headless flag to Windows

headless/lib/headless_browser_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/command_line.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/memory/ptr_util.h"
@@ skipping 378 matching lines @@
 #endif  // !defined(OS_MACOSX)
   EXPECT_EQ(kDefaultOptions.window_size.width(), window_width);
   EXPECT_EQ(kDefaultOptions.window_size.height(), window_height);
 }
 
 namespace {
 
 class ProtocolHandlerWithCookies
     : public net::URLRequestJobFactory::ProtocolHandler {
  public:
-  ProtocolHandlerWithCookies(net::CookieList* sent_cookies);
+  explicit ProtocolHandlerWithCookies(net::CookieList* sent_cookies);
   ~ProtocolHandlerWithCookies() override {}
 
   net::URLRequestJob* MaybeCreateJob(
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate) const override;
 
  private:
   net::CookieList* sent_cookies_;  // Not owned.
 
   DISALLOW_COPY_AND_ASSIGN(ProtocolHandlerWithCookies);
@@ skipping 213 matching lines @@
 
   // We should have sent the matching cookies this time.
   EXPECT_EQ(1u, sent_cookies.size());
   EXPECT_EQ("shape", sent_cookies[0].Name());
   EXPECT_EQ("oblong", sent_cookies[0].Value());
 }
 
 // TODO(skyostil): This test currently relies on being able to run a shell
 // script.
 #if defined(OS_POSIX)
-#define MAYBE_RendererCommandPrefixTest RendererCommandPrefixTest
-#else
-#define MAYBE_RendererCommandPrefixTest DISABLED_RendererCommandPrefixTest
-#endif  // defined(OS_POSIX)
-IN_PROC_BROWSER_TEST_F(HeadlessBrowserTest, MAYBE_RendererCommandPrefixTest) {
+IN_PROC_BROWSER_TEST_F(HeadlessBrowserTest, RendererCommandPrefixTest) {
   base::ThreadRestrictions::SetIOAllowed(true);
   base::FilePath launcher_stamp;
   base::CreateTemporaryFile(&launcher_stamp);
 
   base::FilePath launcher_script;
   FILE* launcher_file = base::CreateAndOpenTemporaryFile(&launcher_script);
   fprintf(launcher_file, "#!/bin/sh\n");
   fprintf(launcher_file, "echo $@ > %s\n", launcher_stamp.value().c_str());
   fprintf(launcher_file, "exec $@\n");
   fclose(launcher_file);
@@ skipping 17 matching lines @@
   EXPECT_TRUE(WaitForLoad(web_contents));
 
   // Make sure the launcher was invoked when starting the renderer.
   std::string stamp;
   EXPECT_TRUE(base::ReadFileToString(launcher_stamp, &stamp));
   EXPECT_GE(stamp.find("--type=renderer"), 0u);
 
   base::DeleteFile(launcher_script, false);
   base::DeleteFile(launcher_stamp, false);
 }
+#endif  // defined(OS_POSIX)
 
 class CrashReporterTest : public HeadlessBrowserTest,
                           public HeadlessWebContents::Observer,
                           inspector::ExperimentalObserver {
  public:
   CrashReporterTest() : devtools_client_(HeadlessDevToolsClient::Create()) {}
   ~CrashReporterTest() override {}
 
   void SetUp() override {
     base::ThreadRestrictions::SetIOAllowed(true);
-    base::CreateNewTempDirectory("CrashReporterTest", &crash_dumps_dir_);
+    base::CreateNewTempDirectory(FILE_PATH_LITERAL("CrashReporterTest"),
+                                 &crash_dumps_dir_);
     EXPECT_FALSE(options()->enable_crash_reporter);
     options()->enable_crash_reporter = true;
     options()->crash_dumps_dir = crash_dumps_dir_;
     HeadlessBrowserTest::SetUp();
   }
 
   void TearDown() override {
     base::ThreadRestrictions::SetIOAllowed(true);
     base::DeleteFile(crash_dumps_dir_, /* recursive */ false);
   }
@@ skipping 47 matching lines @@
   {
 #if defined(OS_MACOSX)
     // Mac outputs dumps in the 'completed' directory.
     crash_dumps_dir_ = crash_dumps_dir_.Append("completed");
 #endif
     base::ThreadRestrictions::SetIOAllowed(true);
     base::FileEnumerator it(crash_dumps_dir_, /* recursive */ false,
                             base::FileEnumerator::FILES);
     base::FilePath minidump = it.Next();
     EXPECT_FALSE(minidump.empty());
-    EXPECT_EQ(".dmp", minidump.Extension());
+    EXPECT_EQ(FILE_PATH_LITERAL(".dmp"), minidump.Extension());
     EXPECT_TRUE(it.Next().empty());
   }
 
   web_contents_->RemoveObserver(this);
   web_contents_->Close();
   web_contents_ = nullptr;
 
   browser_context_->Close();
   browser_context_ = nullptr;
 }
@@ skipping 21 matching lines @@
                 content::PermissionType::NOTIFICATIONS, url, url));
 }
 
 class HeadlessBrowserTestWithNetLog : public HeadlessBrowserTest {
  public:
   HeadlessBrowserTestWithNetLog() {}
 
   void SetUp() override {
     base::ThreadRestrictions::SetIOAllowed(true);
     EXPECT_TRUE(base::CreateTemporaryFile(&net_log_));
-    base::CommandLine::ForCurrentProcess()->AppendSwitchASCII("--log-net-log",
-                                                              net_log_.value());
+    base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
+        "--log-net-log", net_log_.MaybeAsASCII());
     HeadlessBrowserTest::SetUp();
   }
 
   void TearDown() override {
     HeadlessBrowserTest::TearDown();
     base::DeleteFile(net_log_, false);
   }
 
  protected:
   base::FilePath net_log_;
@@ skipping 84 matching lines @@
 
   TraceHelper helper(this, target);
   RunAsynchronousTest();
 
   std::unique_ptr<base::ListValue> tracing_data = helper.TakeTracingData();
   EXPECT_TRUE(tracing_data);
   EXPECT_LT(0u, tracing_data->GetSize());
 }
 
 }  // namespace headless