chrome/app/chrome_watcher_command_line_win.h

// Copyright (c) 2014 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.

#ifndef CHROME_APP_CHROME_WATCHER_COMMAND_LINE_WIN_H_
#define CHROME_APP_CHROME_WATCHER_COMMAND_LINE_WIN_H_

#include <windows.h>

#include <memory>
#include <vector>

#include "base/command_line.h"
#include "base/files/file_path.h"
#include "base/win/scoped_handle.h"

// Class for configuring the Chrome watcher process via the command-line. This
// accepts configuration from the parent process and generates the required
// command-line.
//
// It provides functionality for the common task of sharing handles from a
// parent to a child process, automatically duplicating them with the
// appropriate permissions. These handles are closed when the generator is
// destroyed so the generator must outlive the process creation.
class ChromeWatcherCommandLineGenerator {
 public:
  explicit ChromeWatcherCommandLineGenerator(const base::FilePath& chrome_exe);
  ~ChromeWatcherCommandLineGenerator();

  // Sets a handle to be shared with the child process. This will duplicate the
  // handle with the inherit flag, with this object retaining ownership of the
  // duplicated handle. As such, this object must live at least until after the
  // watcher process has been created. Returns true on success, false on
  // failure. This can fail if the call to DuplicateHandle fails. Each of these
  // may only be called once.
  bool SetOnInitializedEventHandle(HANDLE on_initialized_event_handle);
  bool SetParentProcessHandle(HANDLE parent_process_handle_);

  // Generates a command-line representing this configuration. Must be run from
  // the main thread of the parent process. This should only be called after the
  // generator is fully configured.
  base::CommandLine GenerateCommandLine();

  // Appends all inherited handles to the provided vector. Does not clear the
  // vector first.
  void GetInheritedHandles(std::vector<HANDLE>* inherited_handles) const;

 protected:
  // Exposed for unittesting.

  // Duplicate the provided |handle|, making it inheritable, and storing it in
  // the provided |scoped_handle|.
  bool SetHandle(HANDLE handle, base::win::ScopedHandle* scoped_handle);

  base::FilePath chrome_exe_;

  // Duplicated inheritable handles that are being shared from the parent to the
  // child.
  base::win::ScopedHandle on_initialized_event_handle_;
  base::win::ScopedHandle parent_process_handle_;

 private:
  DISALLOW_COPY_AND_ASSIGN(ChromeWatcherCommandLineGenerator);
};

// Class for processing a command-line used to start a Chrome Watcher process
// and exposing the resulting configuration and any shared handles. To be used
// within the watcher process.
class ChromeWatcherCommandLine {
 public:
  // Causes the process to explode if any inherited handles weren't taken from
  // this object.
  ~ChromeWatcherCommandLine();

  // Parses the provided command-line used to launch a Chrome Watcher process.
  // If this fails any successfully opened handles will be closed prior to
  // return. Returns a ChromeWatcherCommandLine object on success, nullptr
  // otherwise.
  static std::unique_ptr<ChromeWatcherCommandLine> InterpretCommandLine(
      const base::CommandLine& command_line);

  // Accessors for handles. Any handles not taken from this object at the time
  // of its destruction will cause a terminal error.
  base::win::ScopedHandle TakeOnInitializedEventHandle();
  base::win::ScopedHandle TakeParentProcessHandle();

  // Returns the ID of the main thread in the parent process.
  DWORD main_thread_id() const { return main_thread_id_; }

 private:
  // Private constructor for use by InterpretCommandLine.
  ChromeWatcherCommandLine(HANDLE on_initialized_event_handle,
                           HANDLE parent_process_handle,
                           DWORD main_thread_id);

  base::win::ScopedHandle on_initialized_event_handle_;
  base::win::ScopedHandle parent_process_handle_;

  // The ID of the main thread in the parent process.
  DWORD main_thread_id_;

  DISALLOW_COPY_AND_ASSIGN(ChromeWatcherCommandLine);
};

// Generates a CommandLine that will launch |chrome_exe| in Chrome Watcher mode
// to observe |parent_process|, whose main thread is identified by
// |main_thread_id|. The watcher process will signal |on_initialized_event| when
// its initialization is complete.
base::CommandLine GenerateChromeWatcherCommandLine(
    const base::FilePath& chrome_exe,
    HANDLE parent_process,
    DWORD main_thread_id,
    HANDLE on_initialized_event);

// Interprets the Command Line used to launch a Chrome Watcher process and
// extracts the parent process and initialization event HANDLEs and the parent
// process main thread ID. Verifies that the handles are usable in this process
// before returning them. Returns true if all parameters are successfully parsed
// and false otherwise. In case of partial failure, any successfully parsed
// HANDLEs will be closed.
bool InterpretChromeWatcherCommandLine(
    const base::CommandLine& command_line,
    base::win::ScopedHandle* parent_process,
    DWORD* main_thread_id,
    base::win::ScopedHandle* on_initialized_event);

#endif  // CHROME_APP_CHROME_WATCHER_COMMAND_LINE_WIN_H_