chrome/browser/extensions/api/storage/managed_value_store_cache.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.

#ifndef CHROME_BROWSER_EXTENSIONS_API_STORAGE_MANAGED_VALUE_STORE_CACHE_H_
#define CHROME_BROWSER_EXTENSIONS_API_STORAGE_MANAGED_VALUE_STORE_CACHE_H_

#include <map>
#include <string>

#include "base/basictypes.h"
#include "base/callback_forward.h"
#include "base/compiler_specific.h"
#include "base/files/file_path.h"
#include "base/memory/linked_ptr.h"
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_ptr.h"
#include "base/memory/weak_ptr.h"
#include "chrome/browser/extensions/api/storage/settings_observer.h"
#include "chrome/browser/extensions/api/storage/value_store_cache.h"
#include "chrome/browser/extensions/event_router.h"
#include "chrome/browser/policy/policy_service.h"

class Profile;

namespace policy {
class PolicyMap;
}

namespace extensions {

class PolicyValueStore;
class SettingsStorageFactory;

// A ValueStoreCache that manages a PolicyValueStore for each extension that
// uses the storage.managed namespace. This class observes policy changes and
// which extensions listen for storage.onChanged(), and sends the appropriate
// updates to the corresponding PolicyValueStore on the FILE thread.
class ManagedValueStoreCache : public ValueStoreCache,
                               public policy::PolicyService::Observer,
                               public EventRouter::Observer {
 public:
  // |factory| is used to create databases for the PolicyValueStores.
  // |observers| is the list of SettingsObservers to notify when a ValueStore
  // changes.
  ManagedValueStoreCache(Profile* profile,
                         const scoped_refptr<SettingsStorageFactory>& factory,
                         const scoped_refptr<SettingsObserverList>& observers);
  virtual ~ManagedValueStoreCache();

 private:
  class ExtensionTracker;

  // Maps an extension ID to its PolicyValueStoreMap.
  typedef std::map<std::string, linked_ptr<PolicyValueStore> >
      PolicyValueStoreMap;

  // ValueStoreCache implementation:
  virtual void ShutdownOnUI() OVERRIDE;
  virtual void RunWithValueStoreForExtension(
      const StorageCallback& callback,
      scoped_refptr<const Extension> extension) OVERRIDE;
  virtual void DeleteStorageSoon(const std::string& extension_id) OVERRIDE;

  // PolicyService::Observer implementation:
  virtual void OnPolicyUpdated(const policy::PolicyNamespace& ns,
                               const policy::PolicyMap& previous,
                               const policy::PolicyMap& current) OVERRIDE;

  // Posted by OnPolicyUpdated() to update a PolicyValueStore on the FILE
  // thread.
  void UpdatePolicyOnFILE(const std::string& extension_id,
                          scoped_ptr<policy::PolicyMap> current_policy);

  // EventRouter::Observer implementation:
  virtual void OnListenerAdded(const EventListenerInfo& details) OVERRIDE;

  // Posted by OnListenerAdded() to load or create a PolicyValueStore for the
  // given |extension_id|.
  void CreateForExtensionOnFILE(const std::string& extension_id);

  // Returns an existing PolicyValueStore for |extension_id|, or NULL.
  PolicyValueStore* GetStoreFor(const std::string& extension_id);

  // Creates a new PolicyValueStore for |extension_id|. This may open an
  // existing database, or create a new one. This also sends the current policy
  // for |extension_id| to the database. When |notify_if_changed| is true,
  // a notification is sent with the changes between the current policy and the
  // previously stored policy, if there are any.
  //
  // Since this is used on FILE but must retrieve the current policy, this
  // method first posts GetInitialPolicy() to UI and then resumes in
  // CreateStoreWithInitialPolicy(). If |continuation| is not null then it
  // will be invoked after the store is created.
  //
  // CreateStoreFor() can be safely invoked from any method on the FILE thread.
  // It posts to UI used |weak_this_on_ui_|, so that the task is dropped if
  // ShutdownOnUI() has been invoked. Otherwise, GetInitialPolicy() executes
  // on UI and can safely post CreateStoreWithInitialPolicy to FILE.
  // CreateStoreWithInitialPolicy then guarantees that a store for
  // |extension_id| exists or is created, and then executes the |continuation|;
  // so when the |continuation| executes, a store for |extension_id| is
  // guaranteed to exist.
  void CreateStoreFor(const std::string& extension_id,
                      bool notify_if_changed,
                      const base::Closure& continuation);

  // Helper for CreateStoreFor, invoked on UI.
  void GetInitialPolicy(const std::string& extension_id,
                        bool notify_if_changed,
                        const base::Closure& continuation);

  // Helper for CreateStoreFor, invoked on FILE.
  void CreateStoreWithInitialPolicy(const std::string& extension_id,
                                    bool notify_if_changed,
                                    scoped_ptr<policy::PolicyMap> policy,
                                    const base::Closure& continuation);

  // Helper method to get the PolicyService for |profile_|.
  policy::PolicyService* GetPolicyService();

  // Used to create a WeakPtr valid on the UI thread, so that FILE tasks can
  // post back to UI.
  base::WeakPtrFactory<ManagedValueStoreCache> weak_factory_;

  // A WeakPtr to |this| that is valid on UI. This is used by tasks on the FILE
  // thread to post back to UI.
  base::WeakPtr<ManagedValueStoreCache> weak_this_on_ui_;

  // The profile that owns the extension system being used. This is used to
  // get the PolicyService, the EventRouter and the ExtensionService.
  Profile* profile_;

  // The EventRouter is created before the SettingsFrontend (which owns the
  // instance of this class), and the SettingsFrontend is also destroyed before
  // the EventRouter is. |event_router_| is thus valid for the lifetime of this
  // object, until ShutdownOnUI() is invoked. Lives on UI.
  EventRouter* event_router_;

  // Observes extension loading and unloading, and keeps the Profile's
  // PolicyService aware of the current list of extensions.
  scoped_ptr<ExtensionTracker> extension_tracker_;

  // These live on the FILE thread.
  scoped_refptr<SettingsStorageFactory> storage_factory_;
  scoped_refptr<SettingsObserverList> observers_;
  base::FilePath base_path_;

  // All the PolicyValueStores live on the FILE thread, and |store_map_| can be
  // accessed only on the FILE thread as well.
  PolicyValueStoreMap store_map_;

  DISALLOW_COPY_AND_ASSIGN(ManagedValueStoreCache);
};

}  // namespace extensions

#endif  // CHROME_BROWSER_EXTENSIONS_API_STORAGE_MANAGED_VALUE_STORE_CACHE_H_