[win] Change Chrome Watcher configuration API.

chrome/app/chrome_watcher_command_line_unittest_win.cc

 // Copyright (c) 2014 The Chromium Authors. All rights reserved.

[grt (UTC plus 2), 2015/12/21 20:19:06]

nit: this file should be called chrome_watcher_command_line_win_unittest.cc

[chrisha, 2015/12/21 23:25:30]

Doh! Done.

 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/app/chrome_watcher_command_line_win.h"
 
 #include <windows.h>
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/process/process_handle.h"
 #include "base/win/scoped_handle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+class TestChromeWatcherCommandLineGenerator
+    : public ChromeWatcherCommandLineGenerator {
+ public:
+  explicit TestChromeWatcherCommandLineGenerator(
+      const base::FilePath& chrome_exe)
+      : ChromeWatcherCommandLineGenerator(chrome_exe) {
+  }
+
+  void ReleaseHandlesWithoutClosing() {
+    on_initialized_event_handle_.Take();
+    parent_process_handle_.Take();
+  }
+};
+
+TEST(ChromeWatcherCommandLineTest, EndToEnd) {
+  base::win::ScopedHandle process(::OpenProcess(
+      PROCESS_QUERY_INFORMATION | SYNCHRONIZE,
+      FALSE,  // Not inheritable.
+      ::GetCurrentProcessId()));
+  ASSERT_TRUE(process.Get());
+
+  base::win::ScopedHandle event(::CreateEvent(nullptr, FALSE, FALSE, nullptr));
+  ASSERT_TRUE(event.Get());
+
+  // The above handles are duplicated by the generator.
+  TestChromeWatcherCommandLineGenerator generator(
+      base::FilePath(L"example.exe"));
+  generator.SetOnInitializedEventHandle(event.Get());
+  generator.SetParentProcessHandle(process.Get());
+
+  // Expect there to be two inherited handles created by the generator.
+  std::vector<HANDLE> handles;
+  generator.GetInheritedHandles(&handles);
+  EXPECT_EQ(2u, handles.size());
+
+  base::CommandLine cmd_line = generator.GenerateCommandLine();
+
+  // Release the handles from the generator. Ownership will be picked up by the
+  // interpreter, and this prevents the handle tracking from complaining about
+  // there being two owners of the same handle.
+  generator.ReleaseHandlesWithoutClosing();
+
+  // Parse the command line. This creates scoped vectors around the same handles
+  // that are currently owned by the generator.
+  ChromeWatcherCommandLineInterpreter interpreter;
+  EXPECT_TRUE(interpreter.InterpretCommandLine(cmd_line));
+
+  EXPECT_EQ(::GetCurrentThreadId(), interpreter.main_thread_id());
+
+  // Explicitly take the handles from the interpreter.
+  base::win::ScopedHandle on_init, proc;
+  EXPECT_TRUE(interpreter.TakeOnInitializedEventHandle(&on_init));
+  EXPECT_TRUE(interpreter.TakeParentProcessHandle(&proc));
+}
+
 TEST(ChromeWatcherCommandLineTest, BasicTest) {
   // Ownership of these handles is passed to the ScopedHandles below via
   // InterpretChromeWatcherCommandLine().
   base::ProcessHandle current =
       ::OpenProcess(PROCESS_QUERY_INFORMATION | SYNCHRONIZE,
                     TRUE,  // Inheritable
                     ::GetCurrentProcessId());
   ASSERT_NE(nullptr, current);
 
   HANDLE event = ::CreateEvent(nullptr, FALSE, FALSE, nullptr);
   ASSERT_NE(nullptr, event);
   DWORD current_thread_id = ::GetCurrentThreadId();
   base::CommandLine cmd_line = GenerateChromeWatcherCommandLine(
       base::FilePath(L"example.exe"), current, current_thread_id, event);
 
   base::win::ScopedHandle current_result;
   DWORD current_thread_id_result = 0;
   base::win::ScopedHandle event_result;
   ASSERT_TRUE(InterpretChromeWatcherCommandLine(
       cmd_line, &current_result, &current_thread_id_result, &event_result));
   ASSERT_EQ(current, current_result.Get());
   ASSERT_EQ(current_thread_id, current_thread_id_result);
   ASSERT_EQ(event, event_result.Get());
 }