src/extensions/browser/api/declarative/rules_registry.cc

   1 // Copyright (c) 2012 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 #include "extensions/browser/api/declarative/rules_registry.h"
   6
   7 #include <utility>
   8
   9 #include "base/bind.h"
  10 #include "base/logging.h"
  11 #include "base/message_loop/message_loop.h"
  12 #include "base/metrics/histogram.h"
  13 #include "base/stl_util.h"
  14 #include "base/strings/stringprintf.h"
  15 #include "base/time/time.h"
  16 #include "base/values.h"
  17 #include "content/public/browser/browser_thread.h"
  18 #include "content/public/browser/notification_details.h"
  19 #include "content/public/browser/notification_source.h"
  20 #include "extensions/browser/api/declarative/rules_cache_delegate.h"
  21 #include "extensions/browser/extension_prefs.h"
  22 #include "extensions/browser/extension_system.h"
  23 #include "extensions/browser/state_store.h"
  24 #include "extensions/common/extension.h"
  25
  26 namespace {
  27
  28 const char kSuccess[] = "";
  29 const char kDuplicateRuleId[] = "Duplicate rule ID: %s";
  30
  31 scoped_ptr<base::Value> RulesToValue(
  32     const std::vector<linked_ptr<extensions::RulesRegistry::Rule> >& rules) {
  33   scoped_ptr<base::ListValue> list(new base::ListValue());
  34   for (size_t i = 0; i < rules.size(); ++i)
  35     list->Append(rules[i]->ToValue().release());
  36   return list.PassAs<base::Value>();
  37 }
  38
  39 std::vector<linked_ptr<extensions::RulesRegistry::Rule> > RulesFromValue(
  40     const base::Value* value) {
  41   std::vector<linked_ptr<extensions::RulesRegistry::Rule> > rules;
  42
  43   const base::ListValue* list = NULL;
  44   if (!value || !value->GetAsList(&list))
  45     return rules;
  46
  47   rules.reserve(list->GetSize());
  48   for (size_t i = 0; i < list->GetSize(); ++i) {
  49     const base::DictionaryValue* dict = NULL;
  50     if (!list->GetDictionary(i, &dict))
  51       continue;
  52     linked_ptr<extensions::RulesRegistry::Rule> rule(
  53         new extensions::RulesRegistry::Rule());
  54     if (extensions::RulesRegistry::Rule::Populate(*dict, rule.get()))
  55       rules.push_back(rule);
  56   }
  57
  58   return rules;
  59 }
  60
  61 std::string ToId(int identifier) {
  62   return base::StringPrintf("_%d_", identifier);
  63 }
  64
  65 }  // namespace
  66
  67
  68 namespace extensions {
  69
  70 // RulesRegistry
  71
  72 RulesRegistry::RulesRegistry(content::BrowserContext* browser_context,
  73                              const std::string& event_name,
  74                              content::BrowserThread::ID owner_thread,
  75                              RulesCacheDelegate* cache_delegate,
  76                              const WebViewKey& webview_key)
  77     : browser_context_(browser_context),
  78       owner_thread_(owner_thread),
  79       event_name_(event_name),
  80       webview_key_(webview_key),
  81       ready_(/*signaled=*/!cache_delegate),  // Immediately ready if no cache
  82                                              // delegate to wait for.
  83       weak_ptr_factory_(browser_context_ ? this : NULL),
  84       last_generated_rule_identifier_id_(0) {
  85   if (cache_delegate) {
  86     cache_delegate_ = cache_delegate->GetWeakPtr();
  87     cache_delegate->Init(this);
  88   }
  89 }
  90
  91 std::string RulesRegistry::AddRulesNoFill(
  92     const std::string& extension_id,
  93     const std::vector<linked_ptr<Rule> >& rules) {
  94   DCHECK_CURRENTLY_ON(owner_thread());
  95
  96   // Verify that all rule IDs are new.
  97   for (std::vector<linked_ptr<Rule> >::const_iterator i =
  98       rules.begin(); i != rules.end(); ++i) {
  99     const RuleId& rule_id = *((*i)->id);
 100     // Every rule should have a priority assigned.
 101     DCHECK((*i)->priority);
 102     RulesDictionaryKey key(extension_id, rule_id);
 103     if (rules_.find(key) != rules_.end())
 104       return base::StringPrintf(kDuplicateRuleId, rule_id.c_str());
 105   }
 106
 107   std::string error = AddRulesImpl(extension_id, rules);
 108
 109   if (!error.empty())
 110     return error;
 111
 112   // Commit all rules into |rules_| on success.
 113   for (std::vector<linked_ptr<Rule> >::const_iterator i =
 114       rules.begin(); i != rules.end(); ++i) {
 115     const RuleId& rule_id = *((*i)->id);
 116     RulesDictionaryKey key(extension_id, rule_id);
 117     rules_[key] = *i;
 118   }
 119
 120   MaybeProcessChangedRules(extension_id);
 121   return kSuccess;
 122 }
 123
 124 std::string RulesRegistry::AddRules(
 125     const std::string& extension_id,
 126     const std::vector<linked_ptr<Rule> >& rules) {
 127   DCHECK_CURRENTLY_ON(owner_thread());
 128
 129   std::string error = CheckAndFillInOptionalRules(extension_id, rules);
 130   if (!error.empty())
 131     return error;
 132   FillInOptionalPriorities(rules);
 133
 134   return AddRulesNoFill(extension_id, rules);
 135 }
 136
 137 std::string RulesRegistry::RemoveRules(
 138     const std::string& extension_id,
 139     const std::vector<std::string>& rule_identifiers) {
 140   DCHECK_CURRENTLY_ON(owner_thread());
 141
 142   std::string error = RemoveRulesImpl(extension_id, rule_identifiers);
 143
 144   if (!error.empty())
 145     return error;
 146
 147   for (std::vector<std::string>::const_iterator i = rule_identifiers.begin();
 148        i != rule_identifiers.end();
 149        ++i) {
 150     RulesDictionaryKey lookup_key(extension_id, *i);
 151     rules_.erase(lookup_key);
 152   }
 153
 154   MaybeProcessChangedRules(extension_id);
 155   RemoveUsedRuleIdentifiers(extension_id, rule_identifiers);
 156   return kSuccess;
 157 }
 158
 159 std::string RulesRegistry::RemoveAllRules(const std::string& extension_id) {
 160   std::string result = RulesRegistry::RemoveAllRulesNoStoreUpdate(extension_id);
 161   MaybeProcessChangedRules(extension_id);  // Now update the prefs and store.
 162   return result;
 163 }
 164
 165 std::string RulesRegistry::RemoveAllRulesNoStoreUpdate(
 166     const std::string& extension_id) {
 167   DCHECK_CURRENTLY_ON(owner_thread());
 168
 169   std::string error = RemoveAllRulesImpl(extension_id);
 170
 171   if (!error.empty())
 172     return error;
 173
 174   for (RulesDictionary::const_iterator i = rules_.begin();
 175       i != rules_.end();) {
 176     const RulesDictionaryKey& key = i->first;
 177     ++i;
 178     if (key.first == extension_id)
 179       rules_.erase(key);
 180   }
 181
 182   RemoveAllUsedRuleIdentifiers(extension_id);
 183   return kSuccess;
 184 }
 185
 186 void RulesRegistry::GetRules(const std::string& extension_id,
 187                              const std::vector<std::string>& rule_identifiers,
 188                              std::vector<linked_ptr<Rule> >* out) {
 189   DCHECK_CURRENTLY_ON(owner_thread());
 190
 191   for (std::vector<std::string>::const_iterator i = rule_identifiers.begin();
 192       i != rule_identifiers.end(); ++i) {
 193     RulesDictionaryKey lookup_key(extension_id, *i);
 194     RulesDictionary::iterator entry = rules_.find(lookup_key);
 195     if (entry != rules_.end())
 196       out->push_back(entry->second);
 197   }
 198 }
 199
 200 void RulesRegistry::GetAllRules(const std::string& extension_id,
 201                                 std::vector<linked_ptr<Rule> >* out) {
 202   DCHECK_CURRENTLY_ON(owner_thread());
 203
 204   for (RulesDictionary::const_iterator i = rules_.begin();
 205       i != rules_.end(); ++i) {
 206     const RulesDictionaryKey& key = i->first;
 207     if (key.first == extension_id)
 208       out->push_back(i->second);
 209   }
 210 }
 211
 212 void RulesRegistry::OnExtensionUnloaded(const std::string& extension_id) {
 213   DCHECK_CURRENTLY_ON(owner_thread());
 214   std::string error = RemoveAllRulesImpl(extension_id);
 215   if (!error.empty())
 216     LOG(ERROR) << error;
 217 }
 218
 219 void RulesRegistry::OnExtensionUninstalled(const std::string& extension_id) {
 220   DCHECK_CURRENTLY_ON(owner_thread());
 221   std::string error = RemoveAllRulesNoStoreUpdate(extension_id);
 222   if (!error.empty())
 223     LOG(ERROR) << error;
 224 }
 225
 226 void RulesRegistry::OnExtensionLoaded(const std::string& extension_id) {
 227   DCHECK_CURRENTLY_ON(owner_thread());
 228   std::vector<linked_ptr<Rule> > rules;
 229   GetAllRules(extension_id, &rules);
 230   std::string error = AddRulesImpl(extension_id, rules);
 231   if (!error.empty())
 232     LOG(ERROR) << error;
 233 }
 234
 235 size_t RulesRegistry::GetNumberOfUsedRuleIdentifiersForTesting() const {
 236   size_t entry_count = 0u;
 237   for (RuleIdentifiersMap::const_iterator extension =
 238            used_rule_identifiers_.begin();
 239        extension != used_rule_identifiers_.end();
 240        ++extension) {
 241     // Each extension is counted as 1 just for being there. Otherwise we miss
 242     // keys with empty values.
 243     entry_count += 1u + extension->second.size();
 244   }
 245   return entry_count;
 246 }
 247
 248 void RulesRegistry::DeserializeAndAddRules(
 249     const std::string& extension_id,
 250     scoped_ptr<base::Value> rules) {
 251   DCHECK_CURRENTLY_ON(owner_thread());
 252
 253   AddRulesNoFill(extension_id, RulesFromValue(rules.get()));
 254 }
 255
 256 RulesRegistry::~RulesRegistry() {
 257 }
 258
 259 void RulesRegistry::MarkReady(base::Time storage_init_time) {
 260   DCHECK_CURRENTLY_ON(owner_thread());
 261
 262   if (!storage_init_time.is_null()) {
 263     UMA_HISTOGRAM_TIMES("Extensions.DeclarativeRulesStorageInitialization",
 264                         base::Time::Now() - storage_init_time);
 265   }
 266
 267   ready_.Signal();
 268 }
 269
 270 void RulesRegistry::ProcessChangedRules(const std::string& extension_id) {
 271   DCHECK_CURRENTLY_ON(owner_thread());
 272
 273   DCHECK(ContainsKey(process_changed_rules_requested_, extension_id));
 274   process_changed_rules_requested_[extension_id] = NOT_SCHEDULED_FOR_PROCESSING;
 275
 276   std::vector<linked_ptr<Rule> > new_rules;
 277   GetAllRules(extension_id, &new_rules);
 278   content::BrowserThread::PostTask(
 279       content::BrowserThread::UI,
 280       FROM_HERE,
 281       base::Bind(&RulesCacheDelegate::WriteToStorage,
 282                  cache_delegate_,
 283                  extension_id,
 284                  base::Passed(RulesToValue(new_rules))));
 285 }
 286
 287 void RulesRegistry::MaybeProcessChangedRules(const std::string& extension_id) {
 288   // Read and initialize |process_changed_rules_requested_[extension_id]| if
 289   // necessary. (Note that the insertion below will not overwrite
 290   // |process_changed_rules_requested_[extension_id]| if that already exists.
 291   std::pair<ProcessStateMap::iterator, bool> insertion =
 292       process_changed_rules_requested_.insert(std::make_pair(
 293           extension_id,
 294           browser_context_ ? NOT_SCHEDULED_FOR_PROCESSING : NEVER_PROCESS));
 295   if (insertion.first->second != NOT_SCHEDULED_FOR_PROCESSING)
 296     return;
 297
 298   process_changed_rules_requested_[extension_id] = SCHEDULED_FOR_PROCESSING;
 299   ready_.Post(FROM_HERE,
 300               base::Bind(&RulesRegistry::ProcessChangedRules,
 301                          weak_ptr_factory_.GetWeakPtr(),
 302                          extension_id));
 303 }
 304
 305 bool RulesRegistry::IsUniqueId(const std::string& extension_id,
 306                                const std::string& rule_id) const {
 307   RuleIdentifiersMap::const_iterator identifiers =
 308       used_rule_identifiers_.find(extension_id);
 309   if (identifiers == used_rule_identifiers_.end())
 310     return true;
 311   return identifiers->second.find(rule_id) == identifiers->second.end();
 312 }
 313
 314 std::string RulesRegistry::GenerateUniqueId(const std::string& extension_id) {
 315   while (!IsUniqueId(extension_id, ToId(last_generated_rule_identifier_id_)))
 316     ++last_generated_rule_identifier_id_;
 317   return ToId(last_generated_rule_identifier_id_);
 318 }
 319
 320 std::string RulesRegistry::CheckAndFillInOptionalRules(
 321     const std::string& extension_id,
 322     const std::vector<linked_ptr<Rule> >& rules) {
 323   // IDs we have inserted, in case we need to rollback this operation.
 324   std::vector<std::string> rollback_log;
 325
 326   // First we insert all rules with existing identifier, so that generated
 327   // identifiers cannot collide with identifiers passed by the caller.
 328   for (std::vector<linked_ptr<Rule> >::const_iterator i = rules.begin();
 329        i != rules.end();
 330        ++i) {
 331     Rule* rule = i->get();
 332     if (rule->id.get()) {
 333       std::string id = *(rule->id);
 334       if (!IsUniqueId(extension_id, id)) {
 335         RemoveUsedRuleIdentifiers(extension_id, rollback_log);
 336         return "Id " + id + " was used multiple times.";
 337       }
 338       used_rule_identifiers_[extension_id].insert(id);
 339     }
 340   }
 341   // Now we generate IDs in case they were not specified in the rules. This
 342   // cannot fail so we do not need to keep track of a rollback log.
 343   for (std::vector<linked_ptr<Rule> >::const_iterator i = rules.begin();
 344        i != rules.end();
 345        ++i) {
 346     Rule* rule = i->get();
 347     if (!rule->id.get()) {
 348       rule->id.reset(new std::string(GenerateUniqueId(extension_id)));
 349       used_rule_identifiers_[extension_id].insert(*(rule->id));
 350     }
 351   }
 352   return std::string();
 353 }
 354
 355 void RulesRegistry::FillInOptionalPriorities(
 356     const std::vector<linked_ptr<Rule> >& rules) {
 357   std::vector<linked_ptr<Rule> >::const_iterator i;
 358   for (i = rules.begin(); i != rules.end(); ++i) {
 359     if (!(*i)->priority.get())
 360       (*i)->priority.reset(new int(DEFAULT_PRIORITY));
 361   }
 362 }
 363
 364 void RulesRegistry::RemoveUsedRuleIdentifiers(
 365     const std::string& extension_id,
 366     const std::vector<std::string>& identifiers) {
 367   std::vector<std::string>::const_iterator i;
 368   for (i = identifiers.begin(); i != identifiers.end(); ++i)
 369     used_rule_identifiers_[extension_id].erase(*i);
 370 }
 371
 372 void RulesRegistry::RemoveAllUsedRuleIdentifiers(
 373     const std::string& extension_id) {
 374   used_rule_identifiers_.erase(extension_id);
 375 }
 376
 377 }  // namespace extensions