Move the ProcessType enum out to its own file. This is in preparation for getting rid of ChildPro...

content/browser/browser_child_process_host.cc

 // Copyright (c) 2011 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 "content/browser/browser_child_process_host.h"
 
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
@@ skipping 42 matching lines @@
   }
 
  private:
   int notification_type_;
   ChildProcessInfo info_;
 };
 
 }  // namespace
 
 BrowserChildProcessHost::BrowserChildProcessHost(
-    ChildProcessInfo::ProcessType type)
+    content::ProcessType type)
     : ChildProcessInfo(type, -1),
       ALLOW_THIS_IN_INITIALIZER_LIST(client_(this)),
 #if !defined(OS_WIN)
       ALLOW_THIS_IN_INITIALIZER_LIST(task_factory_(this)),
 #endif
       disconnect_was_alive_(false) {
   AddFilter(new TraceMessageFilter);
 
   g_child_process_list.Get().push_back(this);
 }
@@ skipping 76 matching lines @@
   DCHECK(handle() != base::kNullProcessHandle);
   int exit_code;
   base::TerminationStatus status = GetChildTerminationStatus(&exit_code);
   switch (status) {
     case base::TERMINATION_STATUS_PROCESS_CRASHED:
     case base::TERMINATION_STATUS_ABNORMAL_TERMINATION: {
       OnProcessCrashed(exit_code);
       // Report that this child process crashed.
       Notify(content::NOTIFICATION_CHILD_PROCESS_CRASHED);
       UMA_HISTOGRAM_ENUMERATION("ChildProcess.Crashed",
-                                this->type(), MAX_PROCESS);
+                                this->type(),
+                                content::PROCESS_TYPE_MAX);
       if (disconnect_was_alive_) {
         UMA_HISTOGRAM_ENUMERATION("ChildProcess.CrashedWasAlive",
-                                  this->type(), MAX_PROCESS);
+                                  this->type(),
+                                  content::PROCESS_TYPE_MAX);
       }
       break;
     }
     case base::TERMINATION_STATUS_PROCESS_WAS_KILLED: {
       OnProcessWasKilled(exit_code);
       // Report that this child process was killed.
       Notify(content::NOTIFICATION_CHILD_PROCESS_WAS_KILLED);
       UMA_HISTOGRAM_ENUMERATION("ChildProcess.Killed",
-                                this->type(), MAX_PROCESS);
+                                this->type(),
+                                content::PROCESS_TYPE_MAX);
       if (disconnect_was_alive_) {
         UMA_HISTOGRAM_ENUMERATION("ChildProcess.KilledWasAlive",
-                                  this->type(), MAX_PROCESS);
+                                  this->type(),
+                                  content::PROCESS_TYPE_MAX);
       }
       break;
     }
     case base::TERMINATION_STATUS_STILL_RUNNING: {
       // Exit code not yet available. Ensure we don't wait forever for an exit
       // code.
       if (disconnect_was_alive_) {
         UMA_HISTOGRAM_ENUMERATION("ChildProcess.DisconnectedAlive",
-                                  this->type(), MAX_PROCESS);
+                                  this->type(),
+                                  content::PROCESS_TYPE_MAX);
         break;
       }
       disconnect_was_alive_ = true;
 #if defined(OS_WIN)
       child_watcher_.StartWatching(new base::WaitableEvent(handle()), this);
 #else
       // On non-Windows platforms, give the child process some time to die after
       // disconnecting the channel so that the exit code and termination status
       // become available. This is best effort -- if the process doesn't die
       // within the time limit, this object gets destroyed.
       const int kExitCodeWaitMs = 250;
       MessageLoop::current()->PostDelayedTask(
           FROM_HERE,
           base::Bind(&BrowserChildProcessHost::OnChildDisconnected,
                      task_factory_.GetWeakPtr()),
           kExitCodeWaitMs);
 #endif
       return;
     }
 
     default:
       break;
   }
   UMA_HISTOGRAM_ENUMERATION("ChildProcess.Disconnected",
-                            this->type(), MAX_PROCESS);
+                            this->type(),
+                            content::PROCESS_TYPE_MAX);
   // Notify in the main loop of the disconnection.
   Notify(content::NOTIFICATION_CHILD_PROCESS_HOST_DISCONNECTED);
   OnChildDied();
 }
 
 // The child process handle has been signaled so the exit code is finally
 // available. Unfortunately STILL_ACTIVE (0x103) is a valid exit code in
 // which case we should not call OnChildDisconnected() or else we will be
 // waiting forever.
 void BrowserChildProcessHost::OnWaitableEventSignaled(
@@ skipping 21 matching lines @@
 void BrowserChildProcessHost::ClientHook::OnProcessLaunched() {
   if (!host_->child_process_->GetHandle()) {
     host_->OnChildDied();
     return;
   }
   host_->set_handle(host_->child_process_->GetHandle());
   host_->OnProcessLaunched();
 }
 
 BrowserChildProcessHost::Iterator::Iterator()
-    : all_(true), type_(UNKNOWN_PROCESS) {
+    : all_(true), type_(content::PROCESS_TYPE_UNKNOWN) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)) <<
           "ChildProcessInfo::Iterator must be used on the IO thread.";
   iterator_ = g_child_process_list.Get().begin();
 }
 
-BrowserChildProcessHost::Iterator::Iterator(ChildProcessInfo::ProcessType type)
+BrowserChildProcessHost::Iterator::Iterator(content::ProcessType type)
     : all_(false), type_(type) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)) <<
           "ChildProcessInfo::Iterator must be used on the IO thread.";
   iterator_ = g_child_process_list.Get().begin();
   if (!Done() && (*iterator_)->type() != type_)
     ++(*this);
 }
 
 BrowserChildProcessHost* BrowserChildProcessHost::Iterator::operator++() {
   do {
     ++iterator_;
     if (Done())
       break;
 
     if (!all_ && (*iterator_)->type() != type_)
       continue;
 
     return *iterator_;
   } while (true);
 
   return NULL;
 }
 
 bool BrowserChildProcessHost::Iterator::Done() {
   return iterator_ == g_child_process_list.Get().end();
 }