Componentize //chrome/browser/prefs/tracked.

components/user_prefs/tracked/segregated_pref_store.cc

 // Copyright 2014 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/prefs/tracked/segregated_pref_store.h"
+#include "components/user_prefs/tracked/segregated_pref_store.h"
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/values.h"
 
 SegregatedPrefStore::AggregatingObserver::AggregatingObserver(
     SegregatedPrefStore* outer)
     : outer_(outer),
       failed_sub_initializations_(0),
-      successful_sub_initializations_(0) {}
+      successful_sub_initializations_(0) {
+}
 
 void SegregatedPrefStore::AggregatingObserver::OnPrefValueChanged(
     const std::string& key) {
   // There is no need to tell clients about changes if they have not yet been
   // told about initialization.
   if (failed_sub_initializations_ + successful_sub_initializations_ < 2)
     return;
 
-  FOR_EACH_OBSERVER(
-      PrefStore::Observer, outer_->observers_, OnPrefValueChanged(key));
+  FOR_EACH_OBSERVER(PrefStore::Observer, outer_->observers_,
+                    OnPrefValueChanged(key));
 }
 
 void SegregatedPrefStore::AggregatingObserver::OnInitializationCompleted(
     bool succeeded) {
   if (succeeded)
     ++successful_sub_initializations_;
   else
     ++failed_sub_initializations_;
 
   DCHECK_LE(failed_sub_initializations_ + successful_sub_initializations_, 2);
 
   if (failed_sub_initializations_ + successful_sub_initializations_ == 2) {
     if (successful_sub_initializations_ == 2 && outer_->read_error_delegate_) {
       PersistentPrefStore::PrefReadError read_error = outer_->GetReadError();
       if (read_error != PersistentPrefStore::PREF_READ_ERROR_NONE)
         outer_->read_error_delegate_->OnError(read_error);
     }
 
     FOR_EACH_OBSERVER(
-        PrefStore::Observer,
-        outer_->observers_,
+        PrefStore::Observer, outer_->observers_,
         OnInitializationCompleted(successful_sub_initializations_ == 2));
   }
 }
 
 SegregatedPrefStore::SegregatedPrefStore(
     const scoped_refptr<PersistentPrefStore>& default_pref_store,
     const scoped_refptr<PersistentPrefStore>& selected_pref_store,
     const std::set<std::string>& selected_pref_names)
     : default_pref_store_(default_pref_store),
       selected_pref_store_(selected_pref_store),
@@ skipping 45 matching lines @@
   StoreForKey(key)->ReportValueChanged(key, flags);
 }
 
 void SegregatedPrefStore::SetValueSilently(const std::string& key,
                                            scoped_ptr<base::Value> value,
                                            uint32 flags) {
   StoreForKey(key)->SetValueSilently(key, value.Pass(), flags);
 }
 
 bool SegregatedPrefStore::ReadOnly() const {
-  return selected_pref_store_->ReadOnly() ||
-         default_pref_store_->ReadOnly();
+  return selected_pref_store_->ReadOnly() || default_pref_store_->ReadOnly();
 }
 
 PersistentPrefStore::PrefReadError SegregatedPrefStore::GetReadError() const {
   PersistentPrefStore::PrefReadError read_error =
       default_pref_store_->GetReadError();
   if (read_error == PersistentPrefStore::PREF_READ_ERROR_NONE) {
     read_error = selected_pref_store_->GetReadError();
     // Ignore NO_FILE from selected_pref_store_.
     if (read_error == PersistentPrefStore::PREF_READ_ERROR_NO_FILE)
       read_error = PersistentPrefStore::PREF_READ_ERROR_NONE;
@@ skipping 41 matching lines @@
               ? selected_pref_store_
               : default_pref_store_).get();
 }
 
 const PersistentPrefStore* SegregatedPrefStore::StoreForKey(
     const std::string& key) const {
   return (ContainsKey(selected_preference_names_, key)
               ? selected_pref_store_
               : default_pref_store_).get();
 }