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

ui/base/resource/resource_bundle.h

 // 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.
 
 #ifndef UI_BASE_RESOURCE_RESOURCE_BUNDLE_H_
 #define UI_BASE_RESOURCE_RESOURCE_BUNDLE_H_
 
 #include "build/build_config.h"
 
 #include <map>
@@ skipping 53 matching lines @@
   };
 
   // Delegate class that allows interception of pack file loading and resource
   // requests. The methods of this class may be called on multiple threads.
   class Delegate {
    public:
     // Called before a resource pack file is loaded. Return the full path for
     // the pack file to continue loading or an empty value to cancel loading.
     // |pack_path| will contain the complete default path for the pack file if
     // known or just the pack file name otherwise.
-    virtual FilePath GetPathForResourcePack(const FilePath& pack_path,
-                                            ScaleFactor scale_factor) = 0;
+    virtual base::FilePath GetPathForResourcePack(
+        const base::FilePath& pack_path,
+        ScaleFactor scale_factor) = 0;
 
     // Called before a locale pack file is loaded. Return the full path for
     // the pack file to continue loading or an empty value to cancel loading.
     // |pack_path| will contain the complete default path for the pack file if
     // known or just the pack file name otherwise.
-    virtual FilePath GetPathForLocalePack(const FilePath& pack_path,
-                                          const std::string& locale) = 0;
+    virtual base::FilePath GetPathForLocalePack(
+        const base::FilePath& pack_path,
+        const std::string& locale) = 0;
 
     // Return an image resource or an empty value to attempt retrieval of the
     // default resource.
     virtual gfx::Image GetImageNamed(int resource_id) = 0;
 
     // Return an image resource or an empty value to attempt retrieval of the
     // default resource.
     virtual gfx::Image GetNativeImageNamed(int resource_id, ImageRTL rtl) = 0;
 
     // Return a static memory resource or NULL to attempt retrieval of the
@@ skipping 38 matching lines @@
       const std::string& pref_locale, Delegate* delegate);
 
   // Initialize the ResourceBundle using given file. The second argument
   // controls whether or not ResourceBundle::LoadCommonResources is called.
   // This allows the use of this function in a sandbox without local file
   // access (as on Android).
   static void InitSharedInstanceWithPakFile(
       base::PlatformFile file, bool should_load_common_resources);
 
   // Initialize the ResourceBundle using given data pack path for testing.
-  static void InitSharedInstanceWithPakPath(const FilePath& path);
+  static void InitSharedInstanceWithPakPath(const base::FilePath& path);
 
   // Delete the ResourceBundle for this process if it exists.
   static void CleanupSharedInstance();
 
   // Returns true after the global resource loader instance has been created.
   static bool HasSharedInstance();
 
   // Return the global resource loader instance.
   static ResourceBundle& GetSharedInstance();
 
   // Check if the .pak for the given locale exists.
   bool LocaleDataPakExists(const std::string& locale);
 
   // Registers additional data pack files with this ResourceBundle.  When
   // looking for a DataResource, we will search these files after searching the
   // main module. |path| should be the complete path to the pack file if known
   // or just the pack file name otherwise (the delegate may optionally override
   // this value). |scale_factor| is the scale of images in this resource pak
   // relative to the images in the 1x resource pak. This method is not thread
   // safe! You should call it immediately after calling InitSharedInstance.
-  void AddDataPackFromPath(const FilePath& path, ScaleFactor scale_factor);
+  void AddDataPackFromPath(const base::FilePath& path,
+                           ScaleFactor scale_factor);
 
   // Same as above but using an already open file.
   void AddDataPackFromFile(base::PlatformFile file, ScaleFactor scale_factor);
 
   // Same as AddDataPackFromPath but does not log an error if the pack fails to
   // load.
-  void AddOptionalDataPackFromPath(const FilePath& path,
+  void AddOptionalDataPackFromPath(const base::FilePath& path,
                                    ScaleFactor scale_factor);
 
   // Changes the locale for an already-initialized ResourceBundle, returning the
   // name of the newly-loaded locale.  Future calls to get strings will return
   // the strings for this new locale.  This has no effect on existing or future
   // image resources.  |locale_resources_data_| is protected by a lock for the
   // duration of the swap, as GetLocalizedString() may be concurrently invoked
   // on another thread.
   std::string ReloadLocaleResources(const std::string& pref_locale);
 
@@ skipping 52 matching lines @@
 
   // Returns the font for the specified style.
   const gfx::Font& GetFont(FontStyle style);
 
   // Resets and reloads the cached fonts.  This is useful when the fonts of the
   // system have changed, for example, when the locale has changed.
   void ReloadFonts();
 
   // Overrides the path to the pak file from which the locale resources will be
   // loaded. Pass an empty path to undo.
-  void OverrideLocalePakForTest(const FilePath& pak_path);
+  void OverrideLocalePakForTest(const base::FilePath& pak_path);
 
   // Returns the full pathname of the locale file to load.  May return an empty
   // string if no locale data files are found and |test_file_exists| is true.
   // Used on Android to load the local file in the browser process and pass it
   // to the sandboxed renderer process.
-  FilePath GetLocaleFilePath(const std::string& app_locale,
+  base::FilePath GetLocaleFilePath(const std::string& app_locale,
                              bool test_file_exists);
 
   // Returns the maximum scale factor currently loaded.
   // Returns SCALE_FACTOR_100P if no resource is loaded.
   ScaleFactor max_scale_factor() const {
     return max_scale_factor_;
   }
 
  private:
   FRIEND_TEST_ALL_PREFIXES(ResourceBundleTest, DelegateGetPathForLocalePack);
@@ skipping 11 matching lines @@
   ~ResourceBundle();
 
   // Free skia_images_.
   void FreeImages();
 
   // Load the main resources.
   void LoadCommonResources();
 
   // Implementation for AddDataPackFromPath and AddOptionalDataPackFromPath, if
   // the pack is not |optional| logs an error on failure to load.
-  void AddDataPackFromPathInternal(const FilePath& path,
+  void AddDataPackFromPathInternal(const base::FilePath& path,
                                    ScaleFactor scale_factor,
                                    bool optional);
 
   // Inserts |data_pack| to |data_pack_| and updates |max_scale_factor_|
   // accordingly.
   void AddDataPack(DataPack* data_pack);
 
   // Try to load the locale specific strings from an external data module.
   // Returns the locale that is loaded.
   std::string LoadLocaleResources(const std::string& pref_locale);
 
   // Load test resources in given paths. If either path is empty an empty
   // resource pack is loaded.
-  void LoadTestResources(const FilePath& path, const FilePath& locale_path);
+  void LoadTestResources(const base::FilePath& path,
+                         const base::FilePath& locale_path);
 
   // Unload the locale specific strings and prepares to load new ones. See
   // comments for ReloadLocaleResources().
   void UnloadLocaleResources();
 
   // Initialize all the gfx::Font members if they haven't yet been initialized.
   void LoadFontsIfNecessary();
 
   // Fills the |bitmap| given the data file to look in and the |resource_id|.
   // Returns false if the resource does not exist.
@@ skipping 28 matching lines @@
   // should occur immediately after the IHDR chunk.
   static bool DecodePNG(const unsigned char* buf,
                         size_t size,
                         SkBitmap* bitmap,
                         bool* fell_back_to_1x);
 
   // Returns an empty image for when a resource cannot be loaded. This is a
   // bright red bitmap.
   gfx::Image& GetEmptyImage();
 
-  const FilePath& GetOverriddenPakPath();
+  const base::FilePath& GetOverriddenPakPath();
 
   // This pointer is guaranteed to outlive the ResourceBundle instance and may
   // be NULL.
   Delegate* delegate_;
 
   // Protects |images_| and font-related members.
   scoped_ptr<base::Lock> images_and_fonts_lock_;
 
   // Protects |locale_resources_data_|.
   scoped_ptr<base::Lock> locale_resources_data_lock_;
@@ skipping 16 matching lines @@
   scoped_ptr<gfx::Font> base_font_;
   scoped_ptr<gfx::Font> bold_font_;
   scoped_ptr<gfx::Font> small_font_;
   scoped_ptr<gfx::Font> small_bold_font_;
   scoped_ptr<gfx::Font> medium_font_;
   scoped_ptr<gfx::Font> medium_bold_font_;
   scoped_ptr<gfx::Font> large_font_;
   scoped_ptr<gfx::Font> large_bold_font_;
   scoped_ptr<gfx::Font> web_font_;
 
-  FilePath overridden_pak_path_;
+  base::FilePath overridden_pak_path_;
 
   DISALLOW_COPY_AND_ASSIGN(ResourceBundle);
 };
 
 }  // namespace ui
 
 // TODO(beng): Someday, maybe, get rid of this.
 using ui::ResourceBundle;
 
 #endif  // UI_BASE_RESOURCE_RESOURCE_BUNDLE_H_