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