Move PathExists to base namespace.

chrome/common/chrome_content_client.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/common/chrome_content_client.h"
 
 #include "base/command_line.h"
 #include "base/cpu.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
@@ skipping 119 matching lines @@
 void ComputeBuiltInPlugins(std::vector<content::PepperPluginInfo>* plugins) {
   // PDF.
   //
   // Once we're sandboxed, we can't know if the PDF plugin is available or not;
   // but (on Linux) this function is always called once before we're sandboxed.
   // So the first time through test if the file is available and then skip the
   // check on subsequent calls if yes.
   static bool skip_pdf_file_check = false;
   base::FilePath path;
   if (PathService::Get(chrome::FILE_PDF_PLUGIN, &path)) {
-    if (skip_pdf_file_check || file_util::PathExists(path)) {
+    if (skip_pdf_file_check || base::PathExists(path)) {
       content::PepperPluginInfo pdf;
       pdf.path = path;
       pdf.name = chrome::ChromeContentClient::kPDFPluginName;
       webkit::WebPluginMimeType pdf_mime_type(kPDFPluginMimeType,
                                               kPDFPluginExtension,
                                               kPDFPluginDescription);
       webkit::WebPluginMimeType print_preview_pdf_mime_type(
           kPDFPluginPrintPreviewMimeType,
           kPDFPluginExtension,
           kPDFPluginDescription);
       pdf.mime_types.push_back(pdf_mime_type);
       pdf.mime_types.push_back(print_preview_pdf_mime_type);
       pdf.permissions = kPDFPluginPermissions;
       plugins->push_back(pdf);
 
       skip_pdf_file_check = true;
     }
   }
 
   // Handle Native Client just like the PDF plugin. This means that it is
   // enabled by default for the non-portable case.  This allows apps installed
   // from the Chrome Web Store to use NaCl even if the command line switch
   // isn't set.  For other uses of NaCl we check for the command line switch.
   // Specifically, Portable Native Client is only enabled by the command line
   // switch.
   static bool skip_nacl_file_check = false;
   if (PathService::Get(chrome::FILE_NACL_PLUGIN, &path)) {
-    if (skip_nacl_file_check || file_util::PathExists(path)) {
+    if (skip_nacl_file_check || base::PathExists(path)) {
       content::PepperPluginInfo nacl;
       nacl.path = path;
       nacl.name = chrome::ChromeContentClient::kNaClPluginName;
       webkit::WebPluginMimeType nacl_mime_type(kNaClPluginMimeType,
                                                kNaClPluginExtension,
                                                kNaClPluginDescription);
       nacl.mime_types.push_back(nacl_mime_type);
       if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kEnablePnacl)) {
         webkit::WebPluginMimeType pnacl_mime_type(kPnaclPluginMimeType,
                                                   kPnaclPluginExtension,
                                                   kPnaclPluginDescription);
         nacl.mime_types.push_back(pnacl_mime_type);
       }
       nacl.permissions = kNaClPluginPermissions;
       plugins->push_back(nacl);
 
       skip_nacl_file_check = true;
     }
   }
 
   // TODO(jhorwich|noahric): Remove o3d ppapi code once o3d is replaced
   // entirely with o1d.
   static bool skip_o3d_file_check = false;
   if (PathService::Get(chrome::FILE_O3D_PLUGIN, &path)) {
-    if (skip_o3d_file_check || file_util::PathExists(path)) {
+    if (skip_o3d_file_check || base::PathExists(path)) {
       content::PepperPluginInfo o3d;
       o3d.path = path;
       o3d.name = kO3DPluginName;
       o3d.is_out_of_process = true;
       o3d.is_sandboxed = false;
       o3d.permissions = kO3DPluginPermissions;
       webkit::WebPluginMimeType o3d_mime_type(kO3DPluginMimeType,
                                               kO3DPluginExtension,
                                               kO3DPluginDescription);
       o3d.mime_types.push_back(o3d_mime_type);
       plugins->push_back(o3d);
 
       skip_o3d_file_check = true;
     }
   }
 
   static bool skip_o1d_file_check = false;
   if (PathService::Get(chrome::FILE_O1D_PLUGIN, &path)) {
-    if (skip_o1d_file_check || file_util::PathExists(path)) {
+    if (skip_o1d_file_check || base::PathExists(path)) {
       content::PepperPluginInfo o1d;
       o1d.path = path;
       o1d.name = kO1DPluginName;
       o1d.is_out_of_process = true;
       o1d.is_sandboxed = false;
       o1d.permissions = kO1DPluginPermissions;
       webkit::WebPluginMimeType o1d_mime_type(kO1DPluginMimeType,
                                               kO1DPluginExtension,
                                               kO1DPluginDescription);
       o1d.mime_types.push_back(o1d_mime_type);
       plugins->push_back(o1d);
 
       skip_o1d_file_check = true;
     }
   }
 
   static bool skip_gtalk_file_check = false;
   if (PathService::Get(chrome::FILE_GTALK_PLUGIN, &path)) {
-    if (skip_gtalk_file_check || file_util::PathExists(path)) {
+    if (skip_gtalk_file_check || base::PathExists(path)) {
       content::PepperPluginInfo gtalk;
       gtalk.path = path;
       gtalk.name = kGTalkPluginName;
       gtalk.is_out_of_process = true;
       gtalk.is_sandboxed = false;
       gtalk.permissions = kGTalkPluginPermissions;
       webkit::WebPluginMimeType gtalk_mime_type(kGTalkPluginMimeType,
                                                 kGTalkPluginExtension,
                                                 kGTalkPluginDescription);
       gtalk.mime_types.push_back(gtalk_mime_type);
       plugins->push_back(gtalk);
 
       skip_gtalk_file_check = true;
     }
   }
 
 #if defined(WIDEVINE_CDM_AVAILABLE) && defined(ENABLE_PEPPER_CDMS) && \
     !defined(WIDEVINE_CDM_IS_COMPONENT)
   static bool skip_widevine_cdm_file_check = false;
   if (PathService::Get(chrome::FILE_WIDEVINE_CDM_ADAPTER, &path)) {
-    if (skip_widevine_cdm_file_check || file_util::PathExists(path)) {
+    if (skip_widevine_cdm_file_check || base::PathExists(path)) {
       content::PepperPluginInfo widevine_cdm;
       widevine_cdm.is_out_of_process = true;
       widevine_cdm.path = path;
       widevine_cdm.name = kWidevineCdmDisplayName;
       widevine_cdm.description = kWidevineCdmDescription;
       widevine_cdm.version = WIDEVINE_CDM_VERSION_STRING;
       webkit::WebPluginMimeType widevine_cdm_mime_type(
           kWidevineCdmPluginMimeType,
           kWidevineCdmPluginExtension,
           kWidevineCdmPluginMimeTypeDescription);
@@ skipping 227 matching lines @@
   }
   return false;
 }
 
 std::string ChromeContentClient::GetCarbonInterposePath() const {
   return std::string(kInterposeLibraryPath);
 }
 #endif
 
 }  // namespace chrome