<webview>: Implement declarativeWebRequest API

chrome/browser/extensions/api/declarative/rules_registry_with_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_DECLARATIVE_RULES_REGISTRY_WITH_CACHE_H__
 #define CHROME_BROWSER_EXTENSIONS_API_DECLARATIVE_RULES_REGISTRY_WITH_CACHE_H__
 
 #include "chrome/browser/extensions/api/declarative/rules_registry.h"
 
 #include <map>
@@ skipping 32 matching lines @@
   // registering rules on initialization will be logged with UMA.
   class RuleStorageOnUI : public content::NotificationObserver {
    public:
     // |event_name| identifies the JavaScript event for which rules are
     // registered. For example, for WebRequestRulesRegistry the name is
     // "declarativeWebRequest.onRequest".
     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);
 
     virtual ~RuleStorageOnUI();
 
     // Returns a key for the state store. The associated preference is a boolean
     // indicating whether there are some declarative rules stored in the rule
     // store.
     static std::string GetRulesStoredKey(const std::string& event_name,
-                                         bool incognito);
+                                         bool incognito,
+                                         const WebViewKey& webview_key);
 
     // Initialize the storage functionality.
     void Init();
 
     void WriteToStorage(const std::string& extension_id,
                         scoped_ptr<base::Value> value);
 
     base::WeakPtr<RuleStorageOnUI> GetWeakPtr() {
       DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
       return weak_ptr_factory_.GetWeakPtr();
@@ skipping 69 matching lines @@
   // the UI thread) is created, a pointer to it is passed to |*ui_part|.
   // If |log_storage_init_delay| is set, the delay caused by loading and
   // registering rules on initialization will be logged with UMA.
   // In tests, |profile| and |ui_part| can be NULL (at the same time). In that
   // case the storage functionality disabled (no RuleStorageOnUI object
   // created) and the |log_storage_init_delay| flag is ignored.
   RulesRegistryWithCache(Profile* profile,
                          const std::string& event_name,
                          content::BrowserThread::ID owner_thread,
                          bool log_storage_init_delay,
-                         scoped_ptr<RuleStorageOnUI>* ui_part);
+                         scoped_ptr<RuleStorageOnUI>* ui_part,
+                         const WebViewKey& webview_key);
 
   const OneShotEvent& ready() const {
     return ready_;
   }
 
   // RulesRegistry implementation:
   virtual std::string AddRules(
       const std::string& extension_id,
       const std::vector<linked_ptr<RulesRegistry::Rule> >& rules) OVERRIDE;
   virtual std::string RemoveRules(
@@ skipping 75 matching lines @@
   const base::WeakPtr<RuleStorageOnUI> storage_on_ui_;
 
   ProcessChangedRulesState process_changed_rules_requested_;
 
   DISALLOW_COPY_AND_ASSIGN(RulesRegistryWithCache);
 };
 
 }  // namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_API_DECLARATIVE_RULES_REGISTRY_WITH_CACHE_H__