Replace FilePath with base::FilePath in some more top level directories.

ui/gl/gl_implementation_win.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 <vector>
 
 #include "base/at_exit.h"
 #include "base/base_paths.h"
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 26 matching lines @@
 
 void GL_BINDING_CALL MarshalClearDepthToClearDepthf(GLclampd depth) {
   glClearDepthf(static_cast<GLclampf>(depth));
 }
 
 void GL_BINDING_CALL MarshalDepthRangeToDepthRangef(GLclampd z_near,
                                                     GLclampd z_far) {
   glDepthRangef(static_cast<GLclampf>(z_near), static_cast<GLclampf>(z_far));
 }
 
-bool LoadD3DXLibrary(const FilePath& module_path,
-                     const FilePath::StringType& name) {
-  base::NativeLibrary library = base::LoadNativeLibrary(FilePath(name), NULL);
+bool LoadD3DXLibrary(const base::FilePath& module_path,
+                     const base::FilePath::StringType& name) {
+  base::NativeLibrary library =
+      base::LoadNativeLibrary(base::FilePath(name), NULL);
   if (!library) {
     library = base::LoadNativeLibrary(module_path.Append(name), NULL);
     if (!library) {
       DVLOG(1) << name << " not found.";
       return false;
     }
   }
   return true;
 }
 
@@ skipping 13 matching lines @@
     return true;
 
   // Allow the main thread or another to initialize these bindings
   // after instituting restrictions on I/O. Going forward they will
   // likely be used in the browser process on most platforms. The
   // one-time initialization cost is small, between 2 and 5 ms.
   base::ThreadRestrictions::ScopedAllowIO allow_io;
 
   switch (implementation) {
     case kGLImplementationOSMesaGL: {
-      FilePath module_path;
+      base::FilePath module_path;
       if (!PathService::Get(base::DIR_MODULE, &module_path)) {
         LOG(ERROR) << "PathService::Get failed.";
         return false;
       }
 
       base::NativeLibrary library = base::LoadNativeLibrary(
           module_path.Append(L"osmesa.dll"), NULL);
       if (!library) {
         DVLOG(1) << "osmesa.dll not found";
         return false;
@@ skipping 11 matching lines @@
 
       SetGLGetProcAddressProc(get_proc_address);
       AddGLNativeLibrary(library);
       SetGLImplementation(kGLImplementationOSMesaGL);
 
       InitializeGLBindingsGL();
       InitializeGLBindingsOSMESA();
       break;
     }
     case kGLImplementationEGLGLES2: {
-      FilePath module_path;
+      base::FilePath module_path;
       if (!PathService::Get(base::DIR_MODULE, &module_path))
         return false;
 
       // Attempt to load the D3DX shader compiler using the default search path
       // and if that fails, using an absolute path. This is to ensure these DLLs
       // are loaded before ANGLE is loaded in case they are not in the default
       // search path. Prefer the post vista version.
       if (base::win::GetVersion() < base::win::VERSION_VISTA ||
           !LoadD3DXLibrary(module_path, kPostVistaD3DCompiler)) {
         LoadD3DXLibrary(module_path, kPreVistaD3DCompiler);
       }
 
-      FilePath gles_path;
+      base::FilePath gles_path;
       const CommandLine* command_line = CommandLine::ForCurrentProcess();
       bool using_swift_shader =
           command_line->GetSwitchValueASCII(switches::kUseGL) == "swiftshader";
       if (using_swift_shader) {
         if (!command_line->HasSwitch(switches::kSwiftShaderPath))
           return false;
         gles_path =
             command_line->GetSwitchValuePath(switches::kSwiftShaderPath);
         // Preload library
         LoadLibrary(L"ddraw.dll");
@@ skipping 49 matching lines @@
       // These two functions take single precision float rather than double
       // precision float parameters in GLES.
       ::gfx::g_driver_gl.fn.glClearDepthFn = MarshalClearDepthToClearDepthf;
       ::gfx::g_driver_gl.fn.glDepthRangeFn = MarshalDepthRangeToDepthRangef;
       break;
     }
     case kGLImplementationDesktopGL: {
       // When using Windows OpenGL, first try wglGetProcAddress and then
       // Windows GetProcAddress.
       base::NativeLibrary library = base::LoadNativeLibrary(
-          FilePath(L"opengl32.dll"), NULL);
+          base::FilePath(L"opengl32.dll"), NULL);
       if (!library) {
         DVLOG(1) << "opengl32.dll not found";
         return false;
       }
 
       GLGetProcAddressProc get_proc_address =
           reinterpret_cast<GLGetProcAddressProc>(
               base::GetFunctionPointerFromNativeLibrary(
                   library, "wglGetProcAddress"));
       if (!get_proc_address) {
@@ skipping 58 matching lines @@
 void ClearGLBindings() {
   ClearGLBindingsEGL();
   ClearGLBindingsGL();
   ClearGLBindingsOSMESA();
   ClearGLBindingsWGL();
   SetGLImplementation(kGLImplementationNone);
   UnloadGLNativeLibraries();
 }
 
 }  // namespace gfx