Replace FilePath with base::FilePath.

chrome/browser/spellchecker/spellcheck_hunspell_dictionary.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/browser/spellchecker/spellcheck_hunspell_dictionary.h"
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
@@ skipping 31 matching lines @@
     if (descriptor != base::kInvalidPlatformFileValue) {
       BrowserThread::PostTask(
           BrowserThread::FILE,
           FROM_HERE,
           base::Bind(&CloseDictionary, descriptor));
       descriptor = base::kInvalidPlatformFileValue;
     }
   }
 
   // The desired location of the dictionary file, whether or not it exists.
-  FilePath path;
+  base::FilePath path;
 
   // The file descriptor/handle for the dictionary file.
   base::PlatformFile descriptor;
 
   DISALLOW_COPY_AND_ASSIGN(DictionaryFile);
 };
 
 namespace {
 
 // Figures out the location for the dictionary, verifies its contents, and opens
 // it. The default place where the spellcheck dictionary resides is
 // chrome::DIR_APP_DICTIONARIES. For systemwide installations on Windows.
 // however, this directory may not have permissions for download. In that case,
 // the alternate directory for download is chrome::DIR_USER_DATA. Returns a
 // scoped pointer to avoid leaking the file descriptor if the caller has been
 // destroyed.
 scoped_ptr<DictionaryFile> InitializeDictionaryLocation(
     const std::string& language) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   scoped_ptr<DictionaryFile> file(new DictionaryFile);
 
   // Initialize the BDICT path. Initialization should be in the FILE thread
   // because it checks if there is a "Dictionaries" directory and create it.
-  FilePath dict_dir;
+  base::FilePath dict_dir;
   PathService::Get(chrome::DIR_APP_DICTIONARIES, &dict_dir);
   file->path = chrome::spellcheck_common::GetVersionedFileName(
       language, dict_dir);
 
 #if defined(OS_WIN)
   // Check if the dictionary exists in the fallback location. If so, use it
   // rather than downloading anew.
   base::FilePath user_dir;
   PathService::Get(chrome::DIR_USER_DATA, &user_dir);
-  FilePath fallback = user_dir.Append(file->path.BaseName());
+  base::FilePath fallback = user_dir.Append(file->path.BaseName());
   if (!file_util::PathExists(file->path) && file_util::PathExists(fallback))
     file->path = fallback;
 #endif
 
   // Read the dictionary file and scan its data to check for corruption. The
   // scoping closes the memory-mapped file before it is opened or deleted.
   bool bdict_is_valid;
   {
     file_util::MemoryMappedFile map;
     bdict_is_valid = file_util::PathExists(file->path) &&
         map.Initialize(file->path) &&
         hunspell::BDict::Verify(reinterpret_cast<const char*>(map.data()),
                                 map.length());
   }
   if (bdict_is_valid) {
     file->descriptor = base::CreatePlatformFile(
         file->path,
         base::PLATFORM_FILE_READ | base::PLATFORM_FILE_OPEN,
         NULL,
         NULL);
   } else {
     file_util::Delete(file->path, false);
   }
 
   return file.Pass();
 }
 
 // Saves |data| to file at |path|. Returns true on successful save, otherwise
 // returns false.
-bool SaveDictionaryData(scoped_ptr<std::string> data, const FilePath& path) {
+bool SaveDictionaryData(scoped_ptr<std::string> data,
+                        const base::FilePath& path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   size_t bytes_written =
       file_util::WriteFile(path, data->data(), data->length());
   if (bytes_written != data->length()) {
     bool success = false;
 #if defined(OS_WIN)
     base::FilePath dict_dir;
     PathService::Get(chrome::DIR_USER_DATA, &dict_dir);
     base::FilePath fallback_file_path =
@@ skipping 213 matching lines @@
 void SpellcheckHunspellDictionary::InformListenersOfInitialization() {
   FOR_EACH_OBSERVER(Observer, observers_, OnHunspellDictionaryInitialized());
 }
 
 void SpellcheckHunspellDictionary::InformListenersOfDownloadFailure() {
   download_status_ = DOWNLOAD_FAILED;
   FOR_EACH_OBSERVER(Observer,
                     observers_,
                     OnHunspellDictionaryDownloadFailure());
 }