Home | History | Annotate | Download | only in declarative 
      1 // Copyright 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #ifndef EXTENSIONS_BROWSER_API_DECLARATIVE_RULES_CACHE_DELEGATE_H__
      6 #define EXTENSIONS_BROWSER_API_DECLARATIVE_RULES_CACHE_DELEGATE_H__
      7 
      8 #include <set>
      9 #include <string>
     10 
     11 #include "base/gtest_prod_util.h"
     12 #include "base/values.h"
     13 #include "content/public/browser/browser_thread.h"
     14 
     15 namespace content {
     16 class BrowserContext;
     17 }
     18 
     19 namespace extensions {
     20 
     21 class RulesRegistry;
     22 
     23 // RulesCacheDelegate implements the part of the RulesRegistry which works on
     24 // the UI thread. It should only be used on the UI thread.
     25 // If |log_storage_init_delay| is set, the delay caused by loading and
     26 // registering rules on initialization will be logged with UMA.
     27 class RulesCacheDelegate {
     28  public:
     29 
     30   explicit RulesCacheDelegate(bool log_storage_init_delay);
     31 
     32   virtual ~RulesCacheDelegate();
     33 
     34   // Returns a key for the state store. The associated preference is a boolean
     35   // indicating whether there are some declarative rules stored in the rule
     36   // store.
     37   static std::string GetRulesStoredKey(const std::string& event_name,
     38                                        bool incognito);
     39 
     40   // Initialize the storage functionality.
     41   void Init(RulesRegistry* registry);
     42 
     43   void WriteToStorage(const std::string& extension_id,
     44                       scoped_ptr<base::Value> value);
     45 
     46   base::WeakPtr<RulesCacheDelegate> GetWeakPtr() {
     47     DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
     48     return weak_ptr_factory_.GetWeakPtr();
     49   }
     50 
     51  private:
     52   FRIEND_TEST_ALL_PREFIXES(RulesRegistryWithCacheTest,
     53                            DeclarativeRulesStored);
     54   FRIEND_TEST_ALL_PREFIXES(RulesRegistryWithCacheTest,
     55                            RulesStoredFlagMultipleRegistries);
     56 
     57   static const char kRulesStoredKey[];
     58 
     59   // Check if we are done reading all data from storage on startup, and notify
     60   // the RulesRegistry on its thread if so. The notification is delivered
     61   // exactly once.
     62   void CheckIfReady();
     63 
     64   // Schedules retrieving rules for already loaded extensions where
     65   // appropriate.
     66   void ReadRulesForInstalledExtensions();
     67 
     68   // Read/write a list of rules serialized to Values.
     69   void ReadFromStorage(const std::string& extension_id);
     70   void ReadFromStorageCallback(const std::string& extension_id,
     71                                scoped_ptr<base::Value> value);
     72 
     73   // Check the preferences whether the extension with |extension_id| has some
     74   // rules stored on disk. If this information is not in the preferences, true
     75   // is returned as a safe default value.
     76   bool GetDeclarativeRulesStored(const std::string& extension_id) const;
     77   // Modify the preference to |rules_stored|.
     78   void SetDeclarativeRulesStored(const std::string& extension_id,
     79                                  bool rules_stored);
     80 
     81   content::BrowserContext* browser_context_;
     82 
     83   // The key under which rules are stored.
     84   std::string storage_key_;
     85 
     86   // The key under which we store whether the rules have been stored.
     87   std::string rules_stored_key_;
     88 
     89   // A set of extension IDs that have rules we are reading from storage.
     90   std::set<std::string> waiting_for_extensions_;
     91 
     92   // We measure the time spent on loading rules on init. The result is logged
     93   // with UMA once per each RulesCacheDelegate instance, unless in Incognito.
     94   base::Time storage_init_time_;
     95   bool log_storage_init_delay_;
     96 
     97   // Weak pointer to post tasks to the owning rules registry.
     98   base::WeakPtr<RulesRegistry> registry_;
     99 
    100   // The thread |registry_| lives on.
    101   content::BrowserThread::ID rules_registry_thread_;
    102 
    103   // We notified the RulesRegistry that the rules are loaded.
    104   bool notified_registry_;
    105 
    106   // Use this factory to generate weak pointers bound to the UI thread.
    107   base::WeakPtrFactory<RulesCacheDelegate> weak_ptr_factory_;
    108 };
    109 
    110 }  // namespace extensions
    111 
    112 #endif  // EXTENSIONS_BROWSER_API_DECLARATIVE_RULES_CACHE_DELEGATE_H__
    113