Replace Profile* in declarative_api with BrowserContext*

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 <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/callback_forward.h"
 #include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "chrome/common/extensions/api/events.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "extensions/common/one_shot_event.h"
 
-class Profile;
+namespace content {
+class BrowserContext;
+}
 
 namespace base {
 class Value;
 }  // namespace base
 
 namespace extensions {
 
 class RulesCacheDelegate;
 
 // A base class for RulesRegistries that takes care of storing the
@@ skipping 12 matching lines @@
     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,
+  // 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);
 
   const OneShotEvent& ready() const {
     return ready_;
   }
 
   // RulesRegistry implementation:
@@ skipping 55 matching lines @@
 
   // 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 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).
@@ skipping 66 matching lines @@
   // uninstalled, that way there is no clash with the preferences being wiped.
   std::string RemoveAllRulesNoStoreUpdate(const std::string& extension_id);
 
   void MarkReady(base::Time storage_init_time);
 
   // Deserialize the rules from the given Value object and add them to the
   // RulesRegistry.
   void DeserializeAndAddRules(const std::string& extension_id,
                               scoped_ptr<base::Value> rules);
 
-  // The profile to which this rules registry belongs.
-  Profile* profile_;
+  // 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_;
 
@@ skipping 49 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__