<webview>: Implement declarativeWebRequest API

chrome/browser/extensions/api/declarative/rules_registry.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_H__
 #define CHROME_BROWSER_EXTENSIONS_API_DECLARATIVE_RULES_REGISTRY_H__
 
 #include "chrome/browser/extensions/api/declarative/rules_registry.h"
 
 #include <map>
@@ skipping 22 matching lines @@
 
 class RulesCacheDelegate;
 
 // A base class for RulesRegistries that takes care of storing the
 // RulesRegistry::Rule objects. It contains all the methods that need to run on
 // the registry thread; methods that need to run on the UI thread are separated
 // in the RulesCacheDelegate object.
 class RulesRegistry : public base::RefCountedThreadSafe<RulesRegistry> {
  public:
   typedef extensions::api::events::Rule Rule;
+  struct WebViewKey {
+    int embedder_process_id;
+    int webview_instance_id;
+    WebViewKey(int embedder_process_id, int webview_instance_id)
+        : embedder_process_id(embedder_process_id),
+          webview_instance_id(webview_instance_id) {}
+    bool operator<(const WebViewKey& other) const {
+      return embedder_process_id < other.embedder_process_id ||
+          ((embedder_process_id == other.embedder_process_id) &&
+           (webview_instance_id < other.webview_instance_id));
+    }
+  };
 
   enum Defaults { DEFAULT_PRIORITY = 100 };
   // After the RulesCacheDelegate object (the part of the registry which runs on
   // the UI thread) is created, a pointer to it is passed to |*ui_part|.
   // In tests, |profile| and |ui_part| can be NULL (at the same time). In that
   // case the storage functionality disabled (no RulesCacheDelegate object
   // created).
   RulesRegistry(Profile* profile,
                 const std::string& event_name,
                 content::BrowserThread::ID owner_thread,
-                RulesCacheDelegate* cache_delegate);
+                RulesCacheDelegate* cache_delegate,
+                const WebViewKey& webview_key);
 
   const OneShotEvent& ready() const {
     return ready_;
   }
 
   // RulesRegistry implementation:
 
   // Registers |rules|, owned by |extension_id| to this RulesRegistry.
   // If a concrete RuleRegistry does not support some of the rules,
   // it may ignore them.
@@ skipping 49 matching lines @@
       std::vector<linked_ptr<RulesRegistry::Rule> >* out);
 
   // Called to notify the RulesRegistry that an extension has been unloaded
   // and all rules of this extension need to be removed.
   void OnExtensionUnloaded(const std::string& extension_id);
 
   // Returns the number of entries in used_rule_identifiers_ for leak detection.
   // Every ExtensionId counts as one entry, even if it contains no rules.
   size_t GetNumberOfUsedRuleIdentifiersForTesting() const;
 
+  // Returns the RulesCacheDelegate. This is used for testing.
+  RulesCacheDelegate* rules_cache_delegate_for_testing() const {
+    return cache_delegate_.get();
+  }
+
   // Returns the profile where the rules registry lives.
   Profile* profile() const { return profile_; }
 
   // Returns the ID of the thread on which the rules registry lives.
   // It is safe to call this function from any thread.
   content::BrowserThread::ID owner_thread() const { return owner_thread_; }
 
   // The name of the event with which rules are registered.
   const std::string& event_name() const { return event_name_; }
 
+  // The key that identifies the webview (or tabs) in which these rules apply.
+  // If the rules apply to the main browser, then this returns the tuple (0, 0).
+  const WebViewKey& webview_key() const {
+    return webview_key_;
+  }
+
  protected:
   virtual ~RulesRegistry();
 
   // These functions need to apply the rules to the browser, while the base
   // class will handle defaulting empty fields before calling *Impl, and will
   // automatically cache the rules and re-call *Impl on browser startup.
   virtual std::string AddRulesImpl(
       const std::string& extension_id,
       const std::vector<linked_ptr<RulesRegistry::Rule> >& rules) = 0;
   virtual std::string RemoveRulesImpl(
@@ skipping 42 matching lines @@
 
   // The profile to which this rules registry belongs.
   Profile* profile_;
 
   // The ID of the thread on which the rules registry lives.
   const content::BrowserThread::ID owner_thread_;
 
   // The name of the event with which rules are registered.
   const std::string event_name_;
 
+  // The key that identifies the context in which these rules apply.
+  WebViewKey webview_key_;
+
   RulesDictionary rules_;
 
   // Signaled when we have finished reading from storage for all extensions that
   // are loaded on startup.
   OneShotEvent ready_;
 
   // The factory needs to be declared before |cache_delegate_|, so that it can
   // produce a pointer as a construction argument for |cache_delegate_|.
   base::WeakPtrFactory<RulesRegistry> weak_ptr_factory_;
 
@@ skipping 39 matching lines @@
   typedef std::map<ExtensionId, std::set<RuleIdentifier> > RuleIdentifiersMap;
   RuleIdentifiersMap used_rule_identifiers_;
   int last_generated_rule_identifier_id_;
 
   DISALLOW_COPY_AND_ASSIGN(RulesRegistry);
 };
 
 }  // namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_API_DECLARATIVE_RULES_REGISTRY_H__