<webview>: Implement declarativeWebRequest API

chrome/browser/extensions/api/declarative/rules_registry_with_cache.cc

 // 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.
 
 #include "chrome/browser/extensions/api/declarative/rules_registry_with_cache.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
@@ skipping 42 matching lines @@
     linked_ptr<extensions::RulesRegistry::Rule> rule(
         new extensions::RulesRegistry::Rule());
     if (extensions::RulesRegistry::Rule::Populate(*dict, rule.get()))
       rules.push_back(rule);
   }
 
   return rules;
 }
 
 // Returns the key to use for storing declarative rules in the state store.
-std::string GetDeclarativeRuleStorageKey(const std::string& event_name,
-                                         bool incognito) {
-  if (incognito)
-    return "declarative_rules.incognito." + event_name;
-  else
-    return "declarative_rules." + event_name;
+std::string GetDeclarativeRuleStorageKey(
+    const std::string& event_name,
+    bool incognito,
+    const extensions::RulesRegistry::WebViewKey& webview_key) {
+  return base::StringPrintf("declarative_rules%s.%s.%d.%d",
+      incognito ? ".incognito" : "",
+          event_name.c_str(), webview_key.first, webview_key.second);

[vabr (Chromium), 2013/10/25 20:40:24]

Is this stable across browser restarts?
As far as I understand, webview_key.first is the process ID of the webview
renderer. It looks to me like what is the process ID of the webview of app A,
can be a process ID of the webview of app B after browser restart. If that's
correct, then we are storing wrong information, which can lead to registered
rules not being restored on browser restart.

In case of changing this, please also update
RulesRegistryWithCache::RuleStorageOnUI::GetRulesStoredKey.

[Fady Samuel, 2013/10/25 22:48:08]

I was hoping to chat with someone about these changes actually. <webview> rules
should never be stored and preserved across browser restarts. I'm not sure how
to best structure that. I'll dig into this locally a bit more and chat with you
about it on Monday.

 }
 
 }  // namespace
 
 
 namespace extensions {
 
 // RulesRegistryWithCache
 
 RulesRegistryWithCache::RulesRegistryWithCache(
     Profile* profile,
     const std::string& event_name,
     content::BrowserThread::ID owner_thread,
     bool log_storage_init_delay,
-    scoped_ptr<RuleStorageOnUI>* ui_part)
-    : RulesRegistry(owner_thread, event_name),
+    scoped_ptr<RuleStorageOnUI>* ui_part,
+    const WebViewKey& webview_key)
+    : RulesRegistry(owner_thread, event_name, webview_key),
       weak_ptr_factory_(profile ? this : NULL),
       storage_on_ui_(
           (profile ? (new RuleStorageOnUI(profile,
                                           event_name,
                                           owner_thread,
                                           weak_ptr_factory_.GetWeakPtr(),
-                                          log_storage_init_delay))->GetWeakPtr()
+                                          log_storage_init_delay,
+                                          webview_key))->GetWeakPtr()
                    : base::WeakPtr<RuleStorageOnUI>())),
       process_changed_rules_requested_(profile ? NOT_SCHEDULED_FOR_PROCESSING
                                                : NEVER_PROCESS) {
   if (!profile) {
     CHECK(!ui_part);
     return;
   }
 
   ui_part->reset(storage_on_ui_.get());
 
@@ skipping 167 matching lines @@
 // RulesRegistryWithCache::RuleStorageOnUI
 
 const char RulesRegistryWithCache::RuleStorageOnUI::kRulesStoredKey[] =
     "has_declarative_rules";
 
 RulesRegistryWithCache::RuleStorageOnUI::RuleStorageOnUI(
     Profile* profile,
     const std::string& event_name,
     content::BrowserThread::ID rules_registry_thread,
     base::WeakPtr<RulesRegistryWithCache> registry,
-    bool log_storage_init_delay)
+    bool log_storage_init_delay,
+    const WebViewKey& webview_key)
     : profile_(profile),
       storage_key_(GetDeclarativeRuleStorageKey(event_name,
-                                                profile->IsOffTheRecord())),
+                                                profile->IsOffTheRecord(),
+                                                webview_key)),
       rules_stored_key_(GetRulesStoredKey(event_name,
-                                          profile->IsOffTheRecord())),
+                                          profile->IsOffTheRecord(),
+                                          webview_key)),
       log_storage_init_delay_(log_storage_init_delay),
       registry_(registry),
       rules_registry_thread_(rules_registry_thread),
       notified_registry_(false),
       weak_ptr_factory_(this) {}
 
 RulesRegistryWithCache::RuleStorageOnUI::~RuleStorageOnUI() {}
 
 // Returns the key to use for storing whether the rules have been stored.
 // static
 std::string RulesRegistryWithCache::RuleStorageOnUI::GetRulesStoredKey(
     const std::string& event_name,
-    bool incognito) {
-  std::string result(kRulesStoredKey);
-  result += incognito ? ".incognito." : ".";
-  return result + event_name;
+    bool incognito,
+    const WebViewKey& webview_key) {
+  return base::StringPrintf("%s.%s%s.%d.%d",
+      kRulesStoredKey, incognito ? "incognito." : "",
+      event_name.c_str(),
+      webview_key.first, webview_key.second);
 }
 
 // This is called from the constructor of RulesRegistryWithCache, so it is
 // important that it both
 // 1. calls no (in particular virtual) methods of the rules registry, and
 // 2. does not create scoped_refptr holding the registry. (A short-lived
 // scoped_refptr might delete the rules registry before it is constructed.)
 void RulesRegistryWithCache::RuleStorageOnUI::Init() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
@@ skipping 164 matching lines @@
     bool rules_stored) {
   CHECK(profile_);
   ExtensionScopedPrefs* extension_prefs = ExtensionPrefs::Get(profile_);
   extension_prefs->UpdateExtensionPref(
       extension_id,
       rules_stored_key_,
       new base::FundamentalValue(rules_stored));
 }
 
 }  // namespace extensions