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

net/url_request/url_request_unittest.h

 // 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.
 
 #ifndef NET_URL_REQUEST_URL_REQUEST_UNITTEST_H_
 #define NET_URL_REQUEST_URL_REQUEST_UNITTEST_H_
 
 #include <sstream>
 #include <string>
 
@@ skipping 167 matching lines @@
   bool received_data_before_response_;
   bool request_failed_;
   std::string data_received_;
 
   // our read buffer
   char buf_[4096];
 };
 
 // This object bounds the lifetime of an external python-based HTTP server
 // that can provide various responses useful for testing.
-class TestServer : public process_util::ProcessFilter {
+class TestServer : public base::ProcessFilter {
  public:
   TestServer(const std::wstring& document_root)
       : process_handle_(NULL),
         is_shutdown_(true) {
     Init(kDefaultHostName, kDefaultPort, document_root, std::wstring());
   }
 
   virtual ~TestServer() {
     Shutdown();
   }
 
   // Implementation of ProcessFilter
   virtual bool Includes(uint32 pid, uint32 parent_pid) const {
     // This function may be called after Shutdown(), in which process_handle_ is
     // set to NULL. Since no process handle is set, it can't be included in the
     // filter.
     if (!process_handle_)
       return false;
     // TODO(port): rationalize return value of GetProcId
-    return pid == (uint32)process_util::GetProcId(process_handle_);
+    return pid == (uint32)base::GetProcId(process_handle_);
   }
 
   GURL TestServerPage(const std::string& path) {
     return GURL(base_address_ + path);
   }
 
   GURL TestServerPageW(const std::wstring& path) {
     return GURL(base_address_ + WideToUTF8(path));
   }
 
@@ skipping 67 matching lines @@
         L"\"" + python_runtime_ + L"\" " + L"\"" + testserver_path +
         L"\" --port=" + UTF8ToWide(port_str) + L" --data-dir=\"" +
         test_data_directory + L"\"";
     if (!cert_path.empty()) {
       command_line.append(L" --https=\"");
       command_line.append(cert_path);
       command_line.append(L"\"");
     }
 
     ASSERT_TRUE(
-        process_util::LaunchApp(command_line, false, true, &process_handle_)) <<
+        base::LaunchApp(command_line, false, true, &process_handle_)) <<
         "Failed to launch " << command_line;
 #elif defined(OS_LINUX)
     bool tlslite_installed = !access("/usr/bin/tls.py", X_OK);
     ASSERT_TRUE(tlslite_installed) << "tlslite not installed?  Please run 'python setup.py install' in third_party/tlslite.";
 
     std::vector<std::string> command_line;
     command_line.push_back("python");
     command_line.push_back(WideToUTF8(testserver_path));
     command_line.push_back("--port=" + port_str);
     command_line.push_back("--data-dir=" + WideToUTF8(test_data_directory));
@@ skipping 43 matching lines @@
     if (process_handle_) {
 #if defined(OS_WIN)
       CloseHandle(process_handle_);
 #endif
       process_handle_ = NULL;
     }
 
     // Make sure we don't leave any stray testserver processes laying around.
     std::wstring testserver_name =
         file_util::GetFilenameFromPath(python_runtime_);
-    process_util::CleanupProcesses(testserver_name, 10000, 1, this);
-    EXPECT_EQ(0, process_util::GetProcessCount(testserver_name, this));
+    base::CleanupProcesses(testserver_name, 10000, 1, this);
+    EXPECT_EQ(0, base::GetProcessCount(testserver_name, this));
 
     is_shutdown_ = true;
   }
 
  private:
   // Used by MakeGETRequest to implement sync load behavior.
   class SyncTestDelegate : public TestDelegate {
    public:
     SyncTestDelegate() : event_(false, false), success_(false) {
     }
@@ skipping 12 matching lines @@
   static void StartGETRequest(const GURL& url, URLRequest::Delegate* delegate) {
     URLRequest* request = new URLRequest(url, delegate);
     request->set_context(new TestURLRequestContext());
     request->set_method("GET");
     request->Start();
     EXPECT_TRUE(request->is_pending());
   }
 
   std::string base_address_;
   std::wstring python_runtime_;
-  ProcessHandle process_handle_;
+  base::ProcessHandle process_handle_;
   bool is_shutdown_;
 };
 
 class HTTPSTestServer : public TestServer {
  public:
    HTTPSTestServer(const std::string& host_name, int port,
                    const std::wstring& document_root,
                    const std::wstring& cert_path) : TestServer(ManualInit()) {
     Init(host_name, port, document_root, cert_path);
   }
 
   virtual std::string scheme() { return std::string("https"); }
 };
 
 #endif  // NET_URL_REQUEST_URL_REQUEST_UNITTEST_H_