Replace FilePath with base::FilePath.

base/prefs/json_pref_store.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 "base/prefs/json_pref_store.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop_proxy.h"
 #include "base/sequenced_task_runner.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/values.h"
 
 namespace {
 
 // Some extensions we'll tack on to copies of the Preferences files.
-const FilePath::CharType* kBadExtension = FILE_PATH_LITERAL("bad");
+const base::FilePath::CharType* kBadExtension = FILE_PATH_LITERAL("bad");
 
 // Differentiates file loading between origin thread and passed
 // (aka file) thread.
 class FileThreadDeserializer
     : public base::RefCountedThreadSafe<FileThreadDeserializer> {
  public:
   FileThreadDeserializer(JsonPrefStore* delegate,
                          base::SequencedTaskRunner* sequenced_task_runner)
       : no_dir_(false),
         error_(PersistentPrefStore::PREF_READ_ERROR_NONE),
         delegate_(delegate),
         sequenced_task_runner_(sequenced_task_runner),
         origin_loop_proxy_(base::MessageLoopProxy::current()) {
   }
 
-  void Start(const FilePath& path) {
+  void Start(const base::FilePath& path) {
     DCHECK(origin_loop_proxy_->BelongsToCurrentThread());
     sequenced_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&FileThreadDeserializer::ReadFileAndReport,
                    this, path));
   }
 
   // Deserializes JSON on the sequenced task runner.
-  void ReadFileAndReport(const FilePath& path) {
+  void ReadFileAndReport(const base::FilePath& path) {
     DCHECK(sequenced_task_runner_->RunsTasksOnCurrentThread());
 
     value_.reset(DoReading(path, &error_, &no_dir_));
 
     origin_loop_proxy_->PostTask(
         FROM_HERE,
         base::Bind(&FileThreadDeserializer::ReportOnOriginThread, this));
   }
 
   // Reports deserialization result on the origin thread.
   void ReportOnOriginThread() {
     DCHECK(origin_loop_proxy_->BelongsToCurrentThread());
     delegate_->OnFileRead(value_.release(), error_, no_dir_);
   }
 
-  static Value* DoReading(const FilePath& path,
+  static Value* DoReading(const base::FilePath& path,
                           PersistentPrefStore::PrefReadError* error,
                           bool* no_dir) {
     int error_code;
     std::string error_msg;
     JSONFileValueSerializer serializer(path);
     Value* value = serializer.Deserialize(&error_code, &error_msg);
     HandleErrors(value, path, error_code, error_msg, error);
     *no_dir = !file_util::PathExists(path.DirName());
     return value;
   }
 
   static void HandleErrors(const Value* value,
-                           const FilePath& path,
+                           const base::FilePath& path,
                            int error_code,
                            const std::string& error_msg,
                            PersistentPrefStore::PrefReadError* error);
 
  private:
   friend class base::RefCountedThreadSafe<FileThreadDeserializer>;
   ~FileThreadDeserializer() {}
 
   bool no_dir_;
   PersistentPrefStore::PrefReadError error_;
   scoped_ptr<Value> value_;
   const scoped_refptr<JsonPrefStore> delegate_;
   const scoped_refptr<base::SequencedTaskRunner> sequenced_task_runner_;
   const scoped_refptr<base::MessageLoopProxy> origin_loop_proxy_;
 };
 
 // static
 void FileThreadDeserializer::HandleErrors(
     const Value* value,
-    const FilePath& path,
+    const base::FilePath& path,
     int error_code,
     const std::string& error_msg,
     PersistentPrefStore::PrefReadError* error) {
   *error = PersistentPrefStore::PREF_READ_ERROR_NONE;
   if (!value) {
     DVLOG(1) << "Error while loading JSON file: " << error_msg
              << ", file: " << path.value();
     switch (error_code) {
       case JSONFileValueSerializer::JSON_ACCESS_DENIED:
         *error = PersistentPrefStore::PREF_READ_ERROR_ACCESS_DENIED;
         break;
       case JSONFileValueSerializer::JSON_CANNOT_READ_FILE:
         *error = PersistentPrefStore::PREF_READ_ERROR_FILE_OTHER;
         break;
       case JSONFileValueSerializer::JSON_FILE_LOCKED:
         *error = PersistentPrefStore::PREF_READ_ERROR_FILE_LOCKED;
         break;
       case JSONFileValueSerializer::JSON_NO_SUCH_FILE:
         *error = PersistentPrefStore::PREF_READ_ERROR_NO_FILE;
         break;
       default:
         *error = PersistentPrefStore::PREF_READ_ERROR_JSON_PARSE;
         // JSON errors indicate file corruption of some sort.
         // Since the file is corrupt, move it to the side and continue with
         // empty preferences.  This will result in them losing their settings.
         // We keep the old file for possible support and debugging assistance
         // as well as to detect if they're seeing these errors repeatedly.
         // TODO(erikkay) Instead, use the last known good file.
-        FilePath bad = path.ReplaceExtension(kBadExtension);
+        base::FilePath bad = path.ReplaceExtension(kBadExtension);
 
         // If they've ever had a parse error before, put them in another bucket.
         // TODO(erikkay) if we keep this error checking for very long, we may
         // want to differentiate between recent and long ago errors.
         if (file_util::PathExists(bad))
           *error = PersistentPrefStore::PREF_READ_ERROR_JSON_REPEAT;
         file_util::Move(path, bad);
         break;
     }
   } else if (!value->IsType(Value::TYPE_DICTIONARY)) {
     *error = PersistentPrefStore::PREF_READ_ERROR_JSON_TYPE;
   }
 }
 
 }  // namespace
 
 scoped_refptr<base::SequencedTaskRunner> JsonPrefStore::GetTaskRunnerForFile(
-    const FilePath& filename,
+    const base::FilePath& filename,
     base::SequencedWorkerPool* worker_pool) {
   std::string token("json_pref_store-");
   token.append(filename.AsUTF8Unsafe());
   return worker_pool->GetSequencedTaskRunnerWithShutdownBehavior(
       worker_pool->GetNamedSequenceToken(token),
       base::SequencedWorkerPool::BLOCK_SHUTDOWN);
 }
 
-JsonPrefStore::JsonPrefStore(const FilePath& filename,
+JsonPrefStore::JsonPrefStore(const base::FilePath& filename,
                              base::SequencedTaskRunner* sequenced_task_runner)
     : path_(filename),
       sequenced_task_runner_(sequenced_task_runner),
       prefs_(new DictionaryValue()),
       read_only_(false),
       writer_(filename, sequenced_task_runner),
       error_delegate_(NULL),
       initialized_(false),
       read_error_(PREF_READ_ERROR_OTHER) {
 }
@@ skipping 184 matching lines @@
         copy->Set(key, new base::ListValue);
     } else if (value->IsType(base::Value::TYPE_DICTIONARY)) {
       const base::DictionaryValue* dict = NULL;
       if (value->GetAsDictionary(&dict) && dict->empty())
         copy->Set(key, new base::DictionaryValue);
     }
   }
 
   return serializer.Serialize(*(copy.get()));
 }