Move chrome/browser/chromeos/process_proxy to chromeos

chromeos/process_proxy/process_proxy_registry.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 "chrome/browser/chromeos/process_proxy/process_proxy_registry.h"
+#include "chromeos/process_proxy/process_proxy_registry.h"
 
 #include "base/bind.h"
 
+namespace chromeos {
+
 namespace {
 
 const char kWatcherThreadName[] = "ProcessWatcherThread";
 
 const char kStdoutOutputType[] = "stdout";
 const char kStderrOutputType[] = "stderr";
 const char kExitOutputType[] = "exit";
 
 const char* ProcessOutputTypeToString(ProcessOutputType type) {
   switch (type) {
@@ skipping 22 matching lines @@
   DCHECK(!other.proxy.get() && !other.watcher_thread.get());
 }
 
 ProcessProxyRegistry::ProcessProxyInfo::~ProcessProxyInfo() {
 }
 
 ProcessProxyRegistry::ProcessProxyRegistry() {
 }
 
 ProcessProxyRegistry::~ProcessProxyRegistry() {
+  // TODO(tbarzic): Fix issue with ProcessProxyRegistry being destroyed
+  // on a different thread (it's a LazyInstance).
+  DetachFromThread();
+
   // Close all proxies we own.
   while (!proxy_map_.empty())
     CloseProcess(proxy_map_.begin()->first);
 }
 
 // static
 ProcessProxyRegistry* ProcessProxyRegistry::Get() {
   return g_process_proxy_registry.Pointer();
 }
 
-bool ProcessProxyRegistry::OpenProcess(const std::string& command, pid_t* pid,
+bool ProcessProxyRegistry::OpenProcess(
+    const std::string& command,
+    pid_t* pid,
     const ProcessOutputCallbackWithPid& callback) {
+  DCHECK(CalledOnValidThread());
+
   // TODO(tbarzic): Instead of creating a new thread for each new process proxy,
   // use one thread for all processes.
   // We will need new thread for proxy's outpu watcher.
   scoped_ptr<base::Thread> watcher_thread(new base::Thread(kWatcherThreadName));
   if (!watcher_thread->Start()) {
     return false;
   }
 
   // Create and open new proxy.
   scoped_refptr<ProcessProxy> proxy(new ProcessProxy());
@@ skipping 17 matching lines @@
   // created because we don't know |pid| then.
   ProcessProxyInfo& info = proxy_map_[*pid];
   info.proxy.swap(proxy);
   info.watcher_thread.reset(watcher_thread.release());
   info.process_id = *pid;
   info.callback = callback;
   return true;
 }
 
 bool ProcessProxyRegistry::SendInput(pid_t pid, const std::string& data) {
+  DCHECK(CalledOnValidThread());
+
   std::map<pid_t, ProcessProxyInfo>::iterator it = proxy_map_.find(pid);
   if (it == proxy_map_.end())
     return false;
   return it->second.proxy->Write(data);
 }
 
 bool ProcessProxyRegistry::CloseProcess(pid_t pid) {
+  DCHECK(CalledOnValidThread());
+
   std::map<pid_t, ProcessProxyInfo>::iterator it = proxy_map_.find(pid);
   if (it == proxy_map_.end())
     return false;
 
   it->second.proxy->Close();
   it->second.watcher_thread->Stop();
   proxy_map_.erase(it);
   return true;
 }
 
 bool ProcessProxyRegistry::OnTerminalResize(pid_t pid, int width, int height) {
+  DCHECK(CalledOnValidThread());
+
   std::map<pid_t, ProcessProxyInfo>::iterator it = proxy_map_.find(pid);
   if (it == proxy_map_.end())
     return false;
 
   return it->second.proxy->OnTerminalResize(width, height);
 }
 
 void ProcessProxyRegistry::OnProcessOutput(pid_t pid,
     ProcessOutputType type, const std::string& data) {
+  DCHECK(CalledOnValidThread());
+
   const char* type_str = ProcessOutputTypeToString(type);
   DCHECK(type_str);
 
   std::map<pid_t, ProcessProxyInfo>::iterator it = proxy_map_.find(pid);
   if (it == proxy_map_.end())
     return;
   it->second.callback.Run(pid, std::string(type_str), data);
 
   // Contact with the slave end of the terminal has been lost. We have to close
   // the process.
   if (type == PROCESS_OUTPUT_TYPE_EXIT)
     CloseProcess(pid);
 }
 
+}  // namespace chromeos