Disable "using base::FilePath" on Linux since it now compiles.

base/process_linux.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.h"
 
 #include <errno.h>
 #include <sys/resource.h>
 
 #include "base/file_util.h"
@@ skipping 20 matching lines @@
 const char kBackground[] = "/chrome_renderers/background";
 const char kProcPath[] = "/proc/%d/cgroup";
 
 struct CGroups {
   // Check for cgroups files. ChromeOS supports these by default. It creates
   // a cgroup mount in /sys/fs/cgroup and then configures two cpu task groups,
   // one contains at most a single foreground renderer and the other contains
   // all background renderers. This allows us to limit the impact of background
   // renderers on foreground ones to a greater level than simple renicing.
   bool enabled;
-  FilePath foreground_file;
-  FilePath background_file;
+  base::FilePath foreground_file;
+  base::FilePath background_file;
 
   CGroups() {
-    foreground_file = FilePath(StringPrintf(kControlPath, kForeground));
-    background_file = FilePath(StringPrintf(kControlPath, kBackground));
+    foreground_file = base::FilePath(StringPrintf(kControlPath, kForeground));
+    background_file = base::FilePath(StringPrintf(kControlPath, kBackground));
     file_util::FileSystemType foreground_type;
     file_util::FileSystemType background_type;
     enabled =
         file_util::GetFileSystemType(foreground_file, &foreground_type) &&
         file_util::GetFileSystemType(background_file, &background_type) &&
         foreground_type == file_util::FILE_SYSTEM_CGROUP &&
         background_type == file_util::FILE_SYSTEM_CGROUP;
   }
 };
 
 base::LazyInstance<CGroups> cgroups = LAZY_INSTANCE_INITIALIZER;
 #else
 const int kBackgroundPriority = 5;
 #endif
 }
 
 namespace base {
 
 bool Process::IsProcessBackgrounded() const {
   DCHECK(process_);
 
 #if defined(OS_CHROMEOS)
   if (cgroups.Get().enabled) {
     std::string proc;
     if (file_util::ReadFileToString(
-        FilePath(StringPrintf(kProcPath, process_)),
+        base::FilePath(StringPrintf(kProcPath, process_)),
         &proc)) {
       std::vector<std::string> proc_parts;
       base::SplitString(proc, ':', &proc_parts);
       DCHECK(proc_parts.size() == 3);
       bool ret = proc_parts[2] == std::string(kBackground);
       return ret;
     } else {
       return false;
     }
   }
 #endif
   return GetPriority() == kBackgroundPriority;
 }
 
 bool Process::SetProcessBackgrounded(bool background) {
   DCHECK(process_);
 
 #if defined(OS_CHROMEOS)
   if (cgroups.Get().enabled) {
     std::string pid = StringPrintf("%d", process_);
-    const FilePath file =
+    const base::FilePath file =
         background ?
             cgroups.Get().background_file : cgroups.Get().foreground_file;
     return file_util::WriteFile(file, pid.c_str(), pid.size()) > 0;
   }
 #endif // OS_CHROMEOS
 
   if (!CanBackgroundProcesses())
     return false;
 
   int priority = background ? kBackgroundPriority : kForegroundPriority;
@@ skipping 22 matching lines @@
   if (cgroups.Get().enabled)
     return true;
 #endif
 
   static LazyInstance<CheckForNicePermission> check_for_nice_permission =
       LAZY_INSTANCE_INITIALIZER;
   return check_for_nice_permission.Get().can_reraise_priority;
 }
 
 }  // namespace base