Replace FilePath with base::FilePath.

base/prefs/public/pref_member.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/public/pref_member.h"
 
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/prefs/public/pref_service_base.h"
@@ skipping 86 matching lines @@
       is_managed_(false) {
 }
 PrefMemberBase::Internal::~Internal() { }
 
 bool PrefMemberBase::Internal::IsOnCorrectThread() const {
   // In unit tests, there may not be a message loop.
   return thread_loop_ == NULL || thread_loop_->BelongsToCurrentThread();
 }
 
 void PrefMemberBase::Internal::UpdateValue(
-    Value* v,
+    base::Value* v,
     bool is_managed,
     bool is_user_modifiable,
     const base::Closure& callback) const {
-  scoped_ptr<Value> value(v);
+  scoped_ptr<base::Value> value(v);
   base::ScopedClosureRunner closure_runner(callback);
   if (IsOnCorrectThread()) {
     bool rv = UpdateValueInternal(*value);
     DCHECK(rv);
     is_managed_ = is_managed;
     is_user_modifiable_ = is_user_modifiable;
   } else {
     bool may_run = thread_loop_->PostTask(
         FROM_HERE,
         base::Bind(&PrefMemberBase::Internal::UpdateValue, this,
                    value.release(), is_managed, is_user_modifiable,
                    closure_runner.Release()));
     DCHECK(may_run);
   }
 }
 
 void PrefMemberBase::Internal::MoveToThread(
     const scoped_refptr<MessageLoopProxy>& message_loop) {
   CheckOnCorrectThread();
   thread_loop_ = message_loop;
 }
 
-bool PrefMemberVectorStringUpdate(const Value& value,
+bool PrefMemberVectorStringUpdate(const base::Value& value,
                                   std::vector<std::string>* string_vector) {
-  if (!value.IsType(Value::TYPE_LIST))
+  if (!value.IsType(base::Value::TYPE_LIST))
     return false;
   const ListValue* list = static_cast<const ListValue*>(&value);
 
   std::vector<std::string> local_vector;
   for (ListValue::const_iterator it = list->begin(); it != list->end(); ++it) {
     std::string string_value;
     if (!(*it)->GetAsString(&string_value))
       return false;
 
     local_vector.push_back(string_value);
   }
 
   string_vector->swap(local_vector);
   return true;
 }
 
 }  // namespace subtle
 
 template <>
 void PrefMember<bool>::UpdatePref(const bool& value) {
   prefs()->SetBoolean(pref_name().c_str(), value);
 }
 
 template <>
-bool PrefMember<bool>::Internal::UpdateValueInternal(const Value& value) const {
+bool PrefMember<bool>::Internal::UpdateValueInternal(
+    const base::Value& value) const {
   return value.GetAsBoolean(&value_);
 }
 
 template <>
 void PrefMember<int>::UpdatePref(const int& value) {
   prefs()->SetInteger(pref_name().c_str(), value);
 }
 
 template <>
-bool PrefMember<int>::Internal::UpdateValueInternal(const Value& value) const {
+bool PrefMember<int>::Internal::UpdateValueInternal(
+    const base::Value& value) const {
   return value.GetAsInteger(&value_);
 }
 
 template <>
 void PrefMember<double>::UpdatePref(const double& value) {
   prefs()->SetDouble(pref_name().c_str(), value);
 }
 
 template <>
-bool PrefMember<double>::Internal::UpdateValueInternal(const Value& value)
+bool PrefMember<double>::Internal::UpdateValueInternal(const base::Value& value)
     const {
   return value.GetAsDouble(&value_);
 }
 
 template <>
 void PrefMember<std::string>::UpdatePref(const std::string& value) {
   prefs()->SetString(pref_name().c_str(), value);
 }
 
 template <>
-bool PrefMember<std::string>::Internal::UpdateValueInternal(const Value& value)
+bool PrefMember<std::string>::Internal::UpdateValueInternal(
+    const base::Value& value)
     const {
   return value.GetAsString(&value_);
 }
 
 template <>
-void PrefMember<FilePath>::UpdatePref(const FilePath& value) {
+void PrefMember<base::FilePath>::UpdatePref(const base::FilePath& value) {
   prefs()->SetFilePath(pref_name().c_str(), value);
 }
 
 template <>
-bool PrefMember<FilePath>::Internal::UpdateValueInternal(const Value& value)
+bool PrefMember<base::FilePath>::Internal::UpdateValueInternal(
+    const base::Value& value)
     const {
   return base::GetValueAsFilePath(value, &value_);
 }
 
 template <>
 void PrefMember<std::vector<std::string> >::UpdatePref(
     const std::vector<std::string>& value) {
   ListValue list_value;
   list_value.AppendStrings(value);
   prefs()->Set(pref_name().c_str(), list_value);
 }
 
 template <>
 bool PrefMember<std::vector<std::string> >::Internal::UpdateValueInternal(
-    const Value& value) const {
+    const base::Value& value) const {
   return subtle::PrefMemberVectorStringUpdate(value, &value_);
 }