Handle policy refresh internally in ConfigurationPolicyPrefStore.

chrome/browser/prefs/pref_value_store.h

 // Copyright (c) 2010 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.
 
 #ifndef CHROME_BROWSER_PREFS_PREF_VALUE_STORE_H_
 #define CHROME_BROWSER_PREFS_PREF_VALUE_STORE_H_
 #pragma once
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
-#include "base/callback.h"
 #include "base/gtest_prod_util.h"
 #include "base/ref_counted.h"
 #include "base/scoped_ptr.h"
 #include "base/values.h"
 #include "chrome/browser/browser_thread.h"
-#include "chrome/common/notification_observer.h"
-#include "chrome/common/notification_registrar.h"
 #include "chrome/common/pref_store.h"
 
 class FilePath;
 class PrefNotifier;
 class PrefStore;
 class Profile;
 
-// TODO(danno, mnissler): Remove after policy refresh cleanup.
-namespace policy {
-class ConfigurationPolicyPrefStore;
-}
-
 // The PrefValueStore manages various sources of values for Preferences
 // (e.g., configuration policies, extensions, and user settings). It returns
 // the value of a Preference from the source with the highest priority, and
 // allows setting user-defined values for preferences that are not managed.
 //
 // Unless otherwise explicitly noted, all of the methods of this class must
 // be called on the UI thread.
-class PrefValueStore : public base::RefCountedThreadSafe<PrefValueStore>,
-                       public NotificationObserver {
+class PrefValueStore : public base::RefCountedThreadSafe<PrefValueStore> {
  public:
   // In decreasing order of precedence:
   //   |managed_platform_prefs| contains all managed platform (non-cloud policy)
   //        preference values.
   //   |device_management_prefs| contains all device management (cloud policy)
   //        preference values.
   //   |extension_prefs| contains preference values set by extensions.
   //   |command_line_prefs| contains preference values set by command-line
   //        switches.
   //   |user_prefs| contains all user-set preference values.
   //   |recommended_prefs| contains all recommended (policy) preference values.
   //   |default_prefs| contains application-default preference values. It must
   //        be non-null if any preferences are to be registered.
   //
   // |pref_notifier| facilitates broadcasting preference change notifications
   // to the world.
   //
   // The |profile| parameter is used to construct a replacement device
   // management pref store. This is done after policy refresh when we swap out
   // the policy pref stores for new ones, so the |profile| pointer needs to be
   // kept around for then. It is safe to pass a NULL pointer for local state
   // preferences.
-  //
-  // TODO(mnissler, danno): Refactor the pref store interface and refresh logic
-  // so refreshes can be handled by the pref store itself without swapping
-  // stores. This way we can get rid of the profile pointer here.
   PrefValueStore(PrefStore* managed_platform_prefs,
                  PrefStore* device_management_prefs,
                  PrefStore* extension_prefs,
                  PrefStore* command_line_prefs,
                  PrefStore* user_prefs,
                  PrefStore* recommended_prefs,
                  PrefStore* default_prefs,
-                 PrefNotifier* pref_notifier,
-                 Profile* profile);
+                 PrefNotifier* pref_notifier);
   virtual ~PrefValueStore();
 
   // Gets the value for the given preference name that has a valid value type;
   // that is, the same type the preference was registered with, or NULL for
   // default values of Dictionaries and Lists. Returns true if a valid value
   // was found in any of the available PrefStores. Most callers should use
   // Preference::GetValue() instead of calling this method directly.
   bool GetValue(const std::string& name, Value** out_value) const;
 
   // Adds a preference to the mapping of names to types.
@@ skipping 128 matching lines @@
   bool GetValueFromStore(const char* name,
                          PrefStoreType store,
                          Value** out_value) const;
 
   // Called upon changes in individual pref stores in order to determine whether
   // the user-visible pref value has changed. Triggers the change notification
   // if the effective value of the preference has changed, or if the store
   // controlling the pref has changed.
   void NotifyPrefChanged(const char* path, PrefStoreType new_store);
 
-  // Called as a result of a notification of policy change. Triggers a reload of
-  // managed platform, device management and recommended preferences from policy
-  // from a Task on the FILE thread.
-  void RefreshPolicyPrefs();
-
-  // Called during policy refresh after ReadPrefs completes on the thread
-  // that initiated the policy refresh. RefreshPolicyPrefsCompletion takes
-  // ownership of the |callback| object.
-  void RefreshPolicyPrefsCompletion(
-      policy::ConfigurationPolicyPrefStore* new_managed_platform_pref_store,
-      policy::ConfigurationPolicyPrefStore* new_device_management_pref_store,
-      policy::ConfigurationPolicyPrefStore* new_recommended_pref_store);
-
-  // Called during policy refresh to do the ReadPrefs on the FILE thread.
-  // RefreshPolicyPrefsOnFileThread takes ownership of the |callback| object.
-  void RefreshPolicyPrefsOnFileThread(
-      BrowserThread::ID calling_thread_id,
-      policy::ConfigurationPolicyPrefStore* new_managed_platform_pref_store,
-      policy::ConfigurationPolicyPrefStore* new_device_management_pref_store,
-      policy::ConfigurationPolicyPrefStore* new_recommended_pref_store);
-
-  // NotificationObserver methods:
-  virtual void Observe(NotificationType type,
-                       const NotificationSource& source,
-                       const NotificationDetails& details);
-
   // Called from the PrefStoreKeeper implementation when a pref value for |key|
   // changed in the pref store for |type|.
   void OnPrefValueChanged(PrefStoreType type, const std::string& key);
 
   // Handle the event that the store for |type| has completed initialization.
   void OnInitializationCompleted(PrefStoreType type);
 
   // Initializes a pref store keeper. Sets up a PrefStoreKeeper that will take
   // ownership of the passed |pref_store|.
   void InitPrefStore(PrefStoreType type, PrefStore* pref_store);
@@ skipping 15 matching lines @@
   PrefStoreKeeper pref_stores_[PREF_STORE_TYPE_MAX + 1];
 
   // Used for generating PREF_CHANGED and PREF_INITIALIZATION_COMPLETED
   // notifications. This is a weak reference, since the notifier is owned by the
   // corresponding PrefService.
   PrefNotifier* pref_notifier_;
 
   // A mapping of preference names to their registered types.
   PrefTypeMap pref_types_;
 
-  // The associated profile, in case this value store is associated with a
-  // profile pref service. Used for recreating the device management pref store
-  // upon policy refresh.
-  Profile* profile_;
-
-  // TODO(mnissler): Remove this after cleaning up policy refresh handling.
-  NotificationRegistrar registrar_;
-
   DISALLOW_COPY_AND_ASSIGN(PrefValueStore);
 };
 
 #endif  // CHROME_BROWSER_PREFS_PREF_VALUE_STORE_H_