Revert of Delete base/prefs and update callers to use components.

components/prefs/pref_member.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.
 //
 // A helper class that stays in sync with a preference (bool, int, real,
 // string or filepath).  For example:
 //
 // class MyClass {
 //  public:
 //   MyClass(PrefService* prefs) {
 //     my_string_.Init(prefs::kHomePage, prefs);
 //   }
 //  private:
 //   StringPrefMember my_string_;
 // };
 //
 // my_string_ should stay in sync with the prefs::kHomePage pref and will
 // update if either the pref changes or if my_string_.SetValue is called.
 //
 // An optional observer can be passed into the Init method which can be used to
 // notify MyClass of changes. Note that if you use SetValue(), the observer
 // will not be notified.
 
-#ifndef COMPONENTS_PREFS_PREF_MEMBER_H_
-#define COMPONENTS_PREFS_PREF_MEMBER_H_
+#ifndef BASE_PREFS_PREF_MEMBER_H_
+#define BASE_PREFS_PREF_MEMBER_H_
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback_forward.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/single_thread_task_runner.h"
 #include "base/values.h"
 #include "components/prefs/base_prefs_export.h"
 #include "components/prefs/pref_observer.h"
 
 class PrefService;
 
 namespace subtle {
 
-class COMPONENTS_PREFS_EXPORT PrefMemberBase : public PrefObserver {
+class BASE_PREFS_EXPORT PrefMemberBase : public PrefObserver {
  public:
   // Type of callback you can register if you need to know the name of
   // the pref that is changing.
   typedef base::Callback<void(const std::string&)> NamedChangeCallback;
 
   PrefService* prefs() { return prefs_; }
   const PrefService* prefs() const { return prefs_; }
 
  protected:
-  class COMPONENTS_PREFS_EXPORT Internal
+  class BASE_PREFS_EXPORT Internal
       : public base::RefCountedThreadSafe<Internal> {
    public:
     Internal();
 
     // Update the value, either by calling |UpdateValueInternal| directly
     // or by dispatching to the right thread.
     // Takes ownership of |value|.
     void UpdateValue(base::Value* value,
                      bool is_managed,
                      bool is_user_modifiable,
@@ skipping 78 matching lines @@
   std::string pref_name_;
   NamedChangeCallback observer_;
   PrefService* prefs_;
 
  protected:
   bool setting_value_;
 };
 
 // This function implements StringListPrefMember::UpdateValue().
 // It is exposed here for testing purposes.
-bool COMPONENTS_PREFS_EXPORT PrefMemberVectorStringUpdate(
+bool BASE_PREFS_EXPORT PrefMemberVectorStringUpdate(
     const base::Value& value,
     std::vector<std::string>* string_vector);
 
 }  // namespace subtle
 
 template <typename ValueType>
 class PrefMember : public subtle::PrefMemberBase {
  public:
   // Defer initialization to an Init method so it's easy to make this class be
   // a member variable.
@@ skipping 91 matching lines @@
     Internal() : value_(ValueType()) {}
 
     ValueType value() {
       CheckOnCorrectThread();
       return value_;
     }
 
    protected:
     ~Internal() override {}
 
-    COMPONENTS_PREFS_EXPORT bool UpdateValueInternal(
+    BASE_PREFS_EXPORT bool UpdateValueInternal(
         const base::Value& value) const override;
 
     // We cache the value of the pref so we don't have to keep walking the pref
     // tree.
     mutable ValueType value_;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(Internal);
   };
 
   Internal* internal() const override { return internal_.get(); }
   void CreateInternal() const override { internal_ = new Internal(); }
 
   // This method is used to do the actual sync with pref of the specified type.
-  void COMPONENTS_PREFS_EXPORT UpdatePref(const ValueType& value);
+  void BASE_PREFS_EXPORT UpdatePref(const ValueType& value);
 
   mutable scoped_refptr<Internal> internal_;
 
   DISALLOW_COPY_AND_ASSIGN(PrefMember);
 };
 
 // Declaration of template specialization need to be repeated here
 // specifically for each specialization (rather than just once above)
 // or at least one of our compilers won't be happy in all cases.
 // Specifically, it was failing on ChromeOS with a complaint about
 // PrefMember<FilePath>::UpdateValueInternal not being defined when
 // built in a chroot with the following parameters:
 //
 // FEATURES="noclean nostrip" USE="-chrome_debug -chrome_remoting
 // -chrome_internal -chrome_pdf component_build"
 // ~/trunk/goma/goma-wrapper cros_chrome_make --board=${BOARD}
 // --install --runhooks
 
 template <>
-COMPONENTS_PREFS_EXPORT void PrefMember<bool>::UpdatePref(const bool& value);
+BASE_PREFS_EXPORT void PrefMember<bool>::UpdatePref(const bool& value);
 
 template <>
-COMPONENTS_PREFS_EXPORT bool PrefMember<bool>::Internal::UpdateValueInternal(
+BASE_PREFS_EXPORT bool PrefMember<bool>::Internal::UpdateValueInternal(
     const base::Value& value) const;
 
 template <>
-COMPONENTS_PREFS_EXPORT void PrefMember<int>::UpdatePref(const int& value);
+BASE_PREFS_EXPORT void PrefMember<int>::UpdatePref(const int& value);
 
 template <>
-COMPONENTS_PREFS_EXPORT bool PrefMember<int>::Internal::UpdateValueInternal(
+BASE_PREFS_EXPORT bool PrefMember<int>::Internal::UpdateValueInternal(
     const base::Value& value) const;
 
 template <>
-COMPONENTS_PREFS_EXPORT void
-PrefMember<double>::UpdatePref(const double& value);
+BASE_PREFS_EXPORT void PrefMember<double>::UpdatePref(const double& value);
 
 template <>
-COMPONENTS_PREFS_EXPORT bool PrefMember<double>::Internal::UpdateValueInternal(
+BASE_PREFS_EXPORT bool PrefMember<double>::Internal::UpdateValueInternal(
     const base::Value& value) const;
 
 template <>
-COMPONENTS_PREFS_EXPORT void PrefMember<std::string>::UpdatePref(
+BASE_PREFS_EXPORT void PrefMember<std::string>::UpdatePref(
     const std::string& value);
 
 template <>
-COMPONENTS_PREFS_EXPORT bool
-PrefMember<std::string>::Internal::UpdateValueInternal(
+BASE_PREFS_EXPORT bool PrefMember<std::string>::Internal::UpdateValueInternal(
     const base::Value& value) const;
 
 template <>
-COMPONENTS_PREFS_EXPORT void PrefMember<base::FilePath>::UpdatePref(
+BASE_PREFS_EXPORT void PrefMember<base::FilePath>::UpdatePref(
     const base::FilePath& value);
 
 template <>
-COMPONENTS_PREFS_EXPORT bool
+BASE_PREFS_EXPORT bool
 PrefMember<base::FilePath>::Internal::UpdateValueInternal(
     const base::Value& value) const;
 
 template <>
-COMPONENTS_PREFS_EXPORT void PrefMember<std::vector<std::string>>::UpdatePref(
+BASE_PREFS_EXPORT void PrefMember<std::vector<std::string> >::UpdatePref(
     const std::vector<std::string>& value);
 
 template <>
-COMPONENTS_PREFS_EXPORT bool
-PrefMember<std::vector<std::string>>::Internal::UpdateValueInternal(
+BASE_PREFS_EXPORT bool
+PrefMember<std::vector<std::string> >::Internal::UpdateValueInternal(
     const base::Value& value) const;
 
 typedef PrefMember<bool> BooleanPrefMember;
 typedef PrefMember<int> IntegerPrefMember;
 typedef PrefMember<double> DoublePrefMember;
 typedef PrefMember<std::string> StringPrefMember;
 typedef PrefMember<base::FilePath> FilePathPrefMember;
 // This preference member is expensive for large string arrays.
-typedef PrefMember<std::vector<std::string>> StringListPrefMember;
+typedef PrefMember<std::vector<std::string> > StringListPrefMember;
 
-#endif  // COMPONENTS_PREFS_PREF_MEMBER_H_
+#endif  // BASE_PREFS_PREF_MEMBER_H_