Cleanup: Remove unneeded base/file_util.h includes in base.

base/process_util_freebsd.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 "base/process_util.h"
 
 #include <ctype.h>
 #include <dirent.h>
 #include <dlfcn.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <sys/sysctl.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <sys/user.h>
 #include <sys/wait.h>
 #include <time.h>
 #include <unistd.h>
 
-#include "base/file_util.h"
 #include "base/logging.h"
 #include "base/string_tokenizer.h"
 #include "base/string_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/sys_info.h"
 
 namespace base {
 
 ProcessId GetParentProcessId(ProcessHandle process) {
@@ skipping 27 matching lines @@
       filter_(filter) {
 
   int mib[] = { CTL_KERN, KERN_PROC, KERN_PROC_UID, getuid() };
 
   bool done = false;
   int try_num = 1;
   const int max_tries = 10;
 
   do {
     size_t len = 0;
-    if (sysctl(mib, arraysize(mib), NULL, &len, NULL, 0) <0 ){
+    if (sysctl(mib, arraysize(mib), NULL, &len, NULL, 0) < 0) {
       LOG(ERROR) << "failed to get the size needed for the process list";
       kinfo_procs_.resize(0);
       done = true;
     } else {
       size_t num_of_kinfo_proc = len / sizeof(struct kinfo_proc);
       // Leave some spare room for process table growth (more could show up
       // between when we check and now)
       num_of_kinfo_proc += 16;
       kinfo_procs_.resize(num_of_kinfo_proc);
       len = num_of_kinfo_proc * sizeof(struct kinfo_proc);
@@ skipping 19 matching lines @@
     kinfo_procs_.resize(0);
   }
 }
 
 ProcessIterator::~ProcessIterator() {
 }
 
 bool ProcessIterator::CheckForNextProcess() {
   std::string data;
 
-  for (; index_of_kinfo_proc_ < kinfo_procs_.size(); ++ index_of_kinfo_proc_) {
+  for (; index_of_kinfo_proc_ < kinfo_procs_.size(); ++index_of_kinfo_proc_) {
     size_t length;
     struct kinfo_proc kinfo = kinfo_procs_[index_of_kinfo_proc_];
     int mib[] = { CTL_KERN, KERN_PROC_ARGS, kinfo.ki_pid };
 
     if ((kinfo.ki_pid > 0) && (kinfo.ki_stat == SZOMB))
       continue;
 
     length = 0;
     if (sysctl(mib, arraysize(mib), NULL, &length, NULL, 0) < 0) {
       LOG(ERROR) << "failed to figure out the buffer size for a command line";
@@ skipping 31 matching lines @@
 
     // Start w/ the next entry next time through
     ++index_of_kinfo_proc_;
 
     return true;
   }
   return false;
 }
 
 bool NamedProcessIterator::IncludeEntry() {
-  if(executable_name_ != entry().exe_file())
+  if (executable_name_ != entry().exe_file())
     return false;
 
   return ProcessIterator::IncludeEntry();
 }
 
 
 ProcessMetrics::ProcessMetrics(ProcessHandle process)
     : process_(process),
       last_time_(0),
       last_system_time_(0),
@@ skipping 113 matching lines @@
 void EnableTerminationOnHeapCorruption() {
   // Nothing to do.
 }
 
 bool AdjustOOMScore(ProcessId process, int score) {
   NOTIMPLEMENTED();
   return false;
 }
 
 }  // namespace base