Add Terminate() to the Process object, have RenderProcessHost use this to avo...

base/process_win.cc

 // Copyright (c) 2006-2008 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 "base/process.h"
 #include "base/logging.h"
 #include "base/process_util.h"
 #include "base/scoped_ptr.h"
 
+namespace base {
+
+void Process::Close() {
+  if (!process_)
+    return;
+  ::CloseHandle(process_);
+  process_ = NULL;
+}
+
+void Process::Terminate(int result_code) {
+  if (!process_)
+    return;
+  ::TerminateProcess(process_, result_code);
+}
+
 bool Process::IsProcessBackgrounded() const {
   DCHECK(process_);
   DWORD priority = GetPriorityClass(process_);
   if (priority == 0)
     return false;  // Failure case.
   return priority == BELOW_NORMAL_PRIORITY_CLASS;
 }
 
 bool Process::SetProcessBackgrounded(bool value) {
   DCHECK(process_);
@@ skipping 16 matching lines @@
   // when it is not going down, we want to be careful not to release
   // too much back to the OS, as it could cause additional paging.
 
   // We use a damping function to lessen the working set over time.
   // As the process grows/shrinks, this algorithm will lag with
   // working set reduction.
   //
   // The intended algorithm is:
   //   TargetWorkingSetSize = (LastWorkingSet/2 + CurrentWorkingSet) /2
 
-  scoped_ptr<process_util::ProcessMetrics> metrics(
-    process_util::ProcessMetrics::CreateProcessMetrics(process_));
-  process_util::WorkingSetKBytes working_set;
+  scoped_ptr<ProcessMetrics> metrics(
+      ProcessMetrics::CreateProcessMetrics(process_));
+  WorkingSetKBytes working_set;
   if (!metrics->GetWorkingSetKBytes(&working_set))
     return false;
 
 
   // We want to compute the amount of working set that the process
   // needs to keep in memory.  Since other processes contain the
   // pages which are shared, we don't need to reserve them in our
   // process, the system already has them tagged.  Keep in mind, we
   // don't get to control *which* pages get released, but if we
   // assume reasonable distribution of pages, this should generally
@@ skipping 30 matching lines @@
     return false;
 
   BOOL rv = SetProcessWorkingSetSize(process_, -1, -1);
   return rv == TRUE;
 }
 
 int32 Process::pid() const {
   if (process_ == 0)
     return 0;
 
-  return process_util::GetProcId(process_);
+  return GetProcId(process_);
 }
 
 bool Process::is_current() const {
   return process_ == GetCurrentProcess();
 }
 
 // static
 Process Process::Current() {
   return Process(GetCurrentProcess());
 }
 
+}  // namespace base