The worker process launcher can now ask the worker to crash.

remoting/host/win/worker_process_launcher.h

 // 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.
 
 #ifndef REMOTING_HOST_WIN_WORKER_PROCESS_LAUNCHER_H_
 #define REMOTING_HOST_WIN_WORKER_PROCESS_LAUNCHER_H_
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/win/scoped_handle.h"
 #include "ipc/ipc_sender.h"
 
 namespace base {
 class SingleThreadTaskRunner;
 } // namespace base
 
 namespace IPC {
 class Listener;
 class Message;
 } // namespace IPC
 
+namespace tracked_objects {
+class Location;
+}  // namespace tracked_objects
+
 namespace remoting {
 
 class WorkerProcessIpcDelegate;
 
 // Launches a worker process that is controlled via an IPC channel. All
 // interaction with the spawned process is through WorkerProcessIpcDelegate and
 // Send() method. In case of error the channel is closed and the worker process
 // is terminated.
 class WorkerProcessLauncher {
  public:
   class Delegate : public IPC::Sender {
    public:
     virtual ~Delegate();
 
+    // Closes the IPC channel.
+    virtual void CloseChannel() = 0;
+
     // Returns PID of the worker process or 0 if it is not available.
     virtual DWORD GetProcessId() const = 0;
 
     // Returns true if the worker process should not be restarted any more.
     virtual bool IsPermanentError(int failure_count) const = 0;
 
     // Terminates the worker process with the given exit code. Destroys the IPC
     // channel created by LaunchProcess().
     virtual void KillProcess(DWORD exit_code) = 0;
 
@@ skipping 13 matching lines @@
   //
   // The caller should call all the methods on this class on
   // the |caller_task_runner| thread. Methods of both delegate interfaces are
   // called on the |caller_task_runner| thread as well.
   WorkerProcessLauncher(
       scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
       scoped_ptr<Delegate> launcher_delegate,
       WorkerProcessIpcDelegate* worker_delegate);
   ~WorkerProcessLauncher();
 
+  // Asks the worker process to crash generating a dump and closes

[Wez, 2013/03/07 01:54:35]

nit: "... crash and generate a dump, and ..."

[alexeypa (please no reviews), 2013/03/07 21:28:30]

Done.

+  // the IPC channel. |location| is passed to the worker so that it is included
+  // to the generated dump. Restarts the worker process forcefully, if it does

[Wez, 2013/03/07 01:54:35]

nit: "... it is on the stack in the dump."

[Wez, 2013/03/07 01:54:35]

nit: Does it always restart it, or just kill it and let higher-level code
restart it if need be?

[alexeypa (please no reviews), 2013/03/07 21:28:30]

Done.

[alexeypa (please no reviews), 2013/03/07 21:28:30]

It always restarts it. If the caller decide to stop the process it should delete
the entire WorkerProcessLauncher object.

+  // not exit on its own.
+  void Crash(const tracked_objects::Location& location);
+
   // Sends an IPC message to the worker process. The message will be silently
   // dropped if Send() is called before Start() or after stutdown has been
   // initiated.
   void Send(IPC::Message* message);
 
  private:
   // The actual implementation resides in WorkerProcessLauncher::Core class.
   class Core;
   scoped_refptr<Core> core_;
 
   DISALLOW_COPY_AND_ASSIGN(WorkerProcessLauncher);
 };
 
 }  // namespace remoting
 
 #endif  // REMOTING_HOST_WIN_WORKER_PROCESS_LAUNCHER_H_