Add FilePath to base namespace.

chrome/browser/themes/browser_theme_pack.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 CHROME_BROWSER_THEMES_BROWSER_THEME_PACK_H_
 #define CHROME_BROWSER_THEMES_BROWSER_THEME_PACK_H_
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/sequenced_task_runner_helpers.h"
 #include "chrome/common/extensions/extension.h"
 #include "content/public/browser/browser_thread.h"
 #include "ui/base/layout.h"
 #include "ui/gfx/color_utils.h"
 
-class FilePath;
-
 namespace base {
 class DictionaryValue;
+class FilePath;
 class RefCountedMemory;
 }
 
 namespace extensions {
 class Extensions;
 }
 
 namespace gfx {
 class Image;
 }
@@ skipping 25 matching lines @@
   // Builds the theme pack from all data from |extension|. This is often done
   // on a separate thread as it takes so long. This can fail and return NULL in
   // the case where the theme has invalid data.
   static scoped_refptr<BrowserThemePack> BuildFromExtension(
       const extensions::Extension* extension);
 
   // Builds the theme pack from a previously performed WriteToDisk(). This
   // operation should be relatively fast, as it should be an mmap() and some
   // pointer swizzling. Returns NULL on any error attempting to read |path|.
   static scoped_refptr<BrowserThemePack> BuildFromDataPack(
-      const FilePath& path, const std::string& expected_id);
+      const base::FilePath& path, const std::string& expected_id);
 
   // Builds a data pack on disk at |path| for future quick loading by
   // BuildFromDataPack(). Often (but not always) called from the file thread;
   // implementation should be threadsafe because neither thread will write to
   // |image_memory_| and the worker thread will keep a reference to prevent
   // destruction.
-  bool WriteToDisk(const FilePath& path) const;
+  bool WriteToDisk(const base::FilePath& path) const;
 
   // If this theme specifies data for the corresponding |id|, return true and
   // write the corresponding value to the output parameter. These functions
   // don't return the default data. These methods should only be called from
   // the UI thread. (But this isn't enforced because of unit tests).
   bool GetTint(int id, color_utils::HSL* hsl) const;
   bool GetColor(int id, SkColor* color) const;
   bool GetDisplayProperty(int id, int* result) const;
 
   // Returns an image if we have a custom image for |id|, otherwise NULL.
@@ skipping 17 matching lines @@
   // track of the pointers. We own these and will delete them when we're done
   // using them.
   typedef std::map<int, const gfx::Image*> ImageCache;
 
   // The raw PNG memory associated with a certain id.
   typedef std::map<int, scoped_refptr<base::RefCountedMemory> > RawImages;
 
   // The type passed to ui::DataPack::WritePack.
   typedef std::map<uint16, base::StringPiece> RawDataForWriting;
 
-  // An association between an id and the FilePath that has the image data.
-  typedef std::map<int, FilePath> FilePathMap;
+  // An association between an id and the base::FilePath that has the image data.
+  typedef std::map<int, base::FilePath> FilePathMap;
 
   // Default. Everything is empty.
   BrowserThemePack();
 
   virtual ~BrowserThemePack();
 
   // Builds a header ready to write to disk.
   void BuildHeader(const extensions::Extension* extension);
 
   // Transforms the JSON tint values into their final versions in the |tints_|
   // array.
   void BuildTintsFromJSON(base::DictionaryValue* tints_value);
 
   // Transforms the JSON color values into their final versions in the
   // |colors_| array and also fills in unspecified colors based on tint values.
   void BuildColorsFromJSON(base::DictionaryValue* color_value);
 
   // Implementation details of BuildColorsFromJSON().
   void ReadColorsFromJSON(base::DictionaryValue* colors_value,
                           std::map<int, SkColor>* temp_colors);
   void GenerateMissingColors(std::map<int, SkColor>* temp_colors);
 
   // Transforms the JSON display properties into |display_properties_|.
   void BuildDisplayPropertiesFromJSON(base::DictionaryValue* display_value);
 
   // Parses the image names out of an extension.
   void ParseImageNamesFromJSON(base::DictionaryValue* images_value,
-                               const FilePath& images_path,
+                               const base::FilePath& images_path,
                                FilePathMap* file_paths) const;
 
   // Creates the data for |source_images_| from |file_paths|.
   void BuildSourceImagesArray(const FilePathMap& file_paths);
 
   // Loads the unmodified images packed in the extension to SkBitmaps. Returns
   // true if all images loaded.
   bool LoadRawBitmapsTo(const FilePathMap& file_paths,
                         ImageCache* image_cache);
 
@@ skipping 102 matching lines @@
   // Cache of images created in BuildFromExtension(). Once the theme pack is
   // created, this cache should only be accessed on the file thread. There
   // should be no IDs in |image_memory_| that are in |images_on_file_thread_|
   // or vice versa.
   ImageCache images_on_file_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(BrowserThemePack);
 };
 
 #endif  // CHROME_BROWSER_THEMES_BROWSER_THEME_PACK_H_