Remove WebViewKey in rules registry.

extensions/browser/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 EXTENSIONS_BROWSER_API_DECLARATIVE_RULES_REGISTRY_H__
 #define EXTENSIONS_BROWSER_API_DECLARATIVE_RULES_REGISTRY_H__
 
 #include <map>
 #include <set>
 #include <string>
@@ 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::core_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, |browser_context| and |ui_part| can be NULL (at the same time).
   // In that case the storage functionality disabled (no RulesCacheDelegate
   // object created).
   RulesRegistry(content::BrowserContext* browser_context,
                 const std::string& event_name,
                 content::BrowserThread::ID owner_thread,
                 RulesCacheDelegate* cache_delegate,
-                const WebViewKey& webview_key);
+                int id);
 
   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 61 matching lines @@
   // Returns the context where the rules registry lives.
   content::BrowserContext* browser_context() { return browser_context_; }
 
   // 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_;
-  }
+  // The unique identifier for this RulesRegistry object.
+  int id() const { return id_; }
 
  protected:
   virtual ~RulesRegistry();
 
   // The precondition for calling this method is that all rules have unique IDs.
   // AddRules establishes this precondition and calls into this method.
   // Stored rules already meet this precondition and so they avoid calling
   // CheckAndFillInOptionalRules for improved performance.
   //
   // Returns an empty string if the function is successful or an error
@@ skipping 63 matching lines @@
   // The context to which this rules registry belongs.
   content::BrowserContext* browser_context_;
 
   // 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_;
+  int id_;
 
   RulesDictionary rules_;
 
   // Signaled when we have finished reading from storage for all extensions that
   // are loaded on startup.
   OneShotEvent ready_;
 
   ProcessStateMap process_changed_rules_requested_;
 
   // Returns whether any existing rule is registered with identifier |rule_id|
@@ skipping 40 matching lines @@
   // safe. The registry only ever associates with one RulesCacheDelegate
   // instance.
   base::WeakPtr<RulesCacheDelegate> cache_delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(RulesRegistry);
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_BROWSER_API_DECLARATIVE_RULES_REGISTRY_H__