[Chromoting] Implement host safe-mode

remoting/host/win/worker_process_launcher.cc

 // Copyright (c) 2012 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 "remoting/host/win/worker_process_launcher.h"
 
 #include <utility>
 
 #include "base/location.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/time/time.h"
 #include "ipc/ipc_message.h"
 #include "remoting/host/chromoting_messages.h"
 #include "remoting/host/host_exit_codes.h"
+#include "remoting/host/switches.h"
 #include "remoting/host/worker_process_ipc_delegate.h"
 
 using base::TimeDelta;
 using base::win::ScopedHandle;
 
 const net::BackoffEntry::Policy kDefaultBackoffPolicy = {
   // Number of initial errors (in sequence) to ignore before applying
   // exponential back-off rules.
   0,
 
@@ skipping 130 matching lines @@
   // disconnected when the worker process is about to exit. Waiting a little bit
   // here allows the worker to exit completely and so, notify
   // |process_watcher_|. As the result KillProcess() will not be called and
   // the original exit code reported by the worker process will be retrieved.
   if (!kill_process_timer_.IsRunning()) {
     kill_process_timer_.Start(FROM_HERE, kill_process_timeout_, this,
                               &WorkerProcessLauncher::StopWorker);
   }
 }
 
+void WorkerProcessLauncher::AppendSwitches(
+    base::CommandLine* command_line) const {
+  DCHECK(command_line);
+  if (start_counter_ == 1) {
+    return;
+  }
+
+  command_line->AppendSwitch(kSafeMode);
+}
+
 void WorkerProcessLauncher::OnObjectSignaled(HANDLE object) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(!process_watcher_.GetWatchedObject());
   DCHECK_EQ(exit_code_, CONTROL_C_EXIT);
   DCHECK_EQ(worker_process_.Get(), object);
 
   // Get exit code of the worker process if it is available.
   if (!::GetExitCodeProcess(worker_process_.Get(), &exit_code_)) {
     PLOG(INFO) << "Failed to query the exit code of the worker process";
     exit_code_ = CONTROL_C_EXIT;
   }
 
   worker_process_.Close();
   StopWorker();
 }
 
 void WorkerProcessLauncher::LaunchWorker() {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(!ipc_enabled_);
   DCHECK(!kill_process_timer_.IsRunning());
   DCHECK(!launch_timer_.IsRunning());
   DCHECK(!process_watcher_.GetWatchedObject());
   DCHECK(!launch_result_timer_.IsRunning());
 
   exit_code_ = CONTROL_C_EXIT;
 
+  start_counter_++;
   // Make sure launching a process will not take forever.
   launch_result_timer_.Start(
       FROM_HERE, base::TimeDelta::FromSeconds(kLaunchResultTimeoutSeconds),
       this, &WorkerProcessLauncher::RecordLaunchResult);
 
   launcher_delegate_->LaunchProcess(this);
 }
 
 void WorkerProcessLauncher::RecordLaunchResult() {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
@@ skipping 57 matching lines @@
     ipc_handler_->OnPermanentError(exit_code_);
     return;
   }
 
   // Schedule the next attempt to launch the worker process.
   launch_timer_.Start(FROM_HERE, launch_backoff_.GetTimeUntilRelease(), this,
                       &WorkerProcessLauncher::LaunchWorker);
 }
 
 } // namespace remoting