Refactor and fix declarative webRequest API permissions

chrome/browser/extensions/extension_system.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/extension_system.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/string_tokenizer.h"
@@ skipping 55 matching lines @@
 
 //
 // ExtensionSystemImpl::Shared
 //
 
 ExtensionSystemImpl::Shared::Shared(Profile* profile)
     : profile_(profile) {
 }
 
 ExtensionSystemImpl::Shared::~Shared() {
-  if (rules_registry_service_.get())
-    rules_registry_service_->Shutdown();
 }
 
 void ExtensionSystemImpl::Shared::InitPrefs() {
   bool extensions_disabled =
       profile_->GetPrefs()->GetBoolean(prefs::kDisableExtensions) ||
       CommandLine::ForCurrentProcess()->HasSwitch(switches::kDisableExtensions);
   extension_prefs_.reset(new ExtensionPrefs(
       profile_->GetPrefs(),
       profile_->GetPath().AppendASCII(ExtensionService::kInstallDirectoryName),
       ExtensionPrefValueMapFactory::GetForProfile(profile_)));
@@ skipping 39 matching lines @@
       profile_,
       CommandLine::ForCurrentProcess(),
       profile_->GetPath().AppendASCII(ExtensionService::kInstallDirectoryName),
       extension_prefs_.get(),
       autoupdate_enabled,
       extensions_enabled));
 
   // These services must be registered before the ExtensionService tries to
   // load any extensions.
   {
-    rules_registry_service_.reset(new RulesRegistryService(profile_));
-    rules_registry_service_->RegisterDefaultRulesRegistries();
-
     management_policy_.reset(new ManagementPolicy);
     RegisterManagementPolicyProviders();
   }
 
   extension_service_->component_loader()->AddDefaultComponentExtensions();
   if (command_line->HasSwitch(switches::kLoadComponentExtension)) {
     CommandLine::StringType path_list = command_line->GetSwitchValueNative(
         switches::kLoadComponentExtension);
     StringTokenizerT<CommandLine::StringType,
         CommandLine::StringType::const_iterator> t(path_list,
@@ skipping 79 matching lines @@
 }
 
 MessageService* ExtensionSystemImpl::Shared::message_service() {
   return message_service_.get();
 }
 
 EventRouter* ExtensionSystemImpl::Shared::event_router() {
   return extension_event_router_.get();
 }
 
-RulesRegistryService* ExtensionSystemImpl::Shared::rules_registry_service() {
-  return rules_registry_service_.get();
-}
-
 //
 // ExtensionSystemImpl
 //
 
 ExtensionSystemImpl::ExtensionSystemImpl(Profile* profile)
     : profile_(profile),
       extension_devtools_manager_(NULL) {
   shared_ = ExtensionSystemSharedFactory::GetForProfile(profile);
 
   if (profile->IsOffTheRecord()) {
     extension_process_manager_.reset(ExtensionProcessManager::Create(profile));
   } else {
     shared_->InitPrefs();
   }
 }
 
 ExtensionSystemImpl::~ExtensionSystemImpl() {
+  if (rules_registry_service_.get())
+    rules_registry_service_->Shutdown();
 }
 
 void ExtensionSystemImpl::Shutdown() {
   extension_process_manager_.reset();
 }
 
-void ExtensionSystemImpl::Init(bool extensions_enabled) {
+void ExtensionSystemImpl::InitForRegularProfile(bool extensions_enabled) {
   DCHECK(!profile_->IsOffTheRecord());
   if (user_script_master() || extension_service())
     return;  // Already initialized.
 
   const CommandLine* command_line = CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(
       switches::kEnableExtensionTimelineApi)) {
     extension_devtools_manager_ = new ExtensionDevToolsManager(profile_);
   }
 
   shared_->InitInfoMap();
 
   extension_process_manager_.reset(ExtensionProcessManager::Create(profile_));
   alarm_manager_.reset(new AlarmManager(profile_, &base::Time::Now));
 
   serial_connection_manager_.reset(new ApiResourceManager<SerialConnection>(
       BrowserThread::FILE));
   socket_manager_.reset(new ApiResourceManager<Socket>(BrowserThread::IO));
   usb_device_resource_manager_.reset(
       new ApiResourceManager<UsbDeviceResource>(BrowserThread::IO));
 
+  rules_registry_service_.reset(new RulesRegistryService(profile_));
+  rules_registry_service_->RegisterDefaultRulesRegistries();
+
   shared_->Init(extensions_enabled);
 }
 
+void ExtensionSystemImpl::InitForOTRProfile() {
+  // Only initialize the RulesRegistryService of the OTR ExtensionSystem if the
+  // regular ExtensionSystem has been initialized properly, as we depend on it.
+  // Some ChromeOS browser tests don't initialize the regular ExtensionSystem
+  // in login-tests.
+  if (extension_service()) {
+    rules_registry_service_.reset(new RulesRegistryService(profile_));
+    rules_registry_service_->RegisterDefaultRulesRegistries();
+  }
+}
+
 ExtensionService* ExtensionSystemImpl::extension_service() {
   return shared_->extension_service();
 }
 
 ManagementPolicy* ExtensionSystemImpl::management_policy() {
   return shared_->management_policy();
 }
 
 UserScriptMaster* ExtensionSystemImpl::user_script_master() {
   return shared_->user_script_master();
@@ skipping 27 matching lines @@
 
 MessageService* ExtensionSystemImpl::message_service() {
   return shared_->message_service();
 }
 
 EventRouter* ExtensionSystemImpl::event_router() {
   return shared_->event_router();
 }
 
 RulesRegistryService* ExtensionSystemImpl::rules_registry_service() {
-  return shared_->rules_registry_service();
+  return rules_registry_service_.get();
 }
 
 ApiResourceManager<SerialConnection>*
 ExtensionSystemImpl::serial_connection_manager() {
   return serial_connection_manager_.get();
 }
 
-ApiResourceManager<Socket>*ExtensionSystemImpl::socket_manager() {
+ApiResourceManager<Socket>* ExtensionSystemImpl::socket_manager() {
   return socket_manager_.get();
 }
 
 ApiResourceManager<UsbDeviceResource>*
 ExtensionSystemImpl::usb_device_resource_manager() {
   return usb_device_resource_manager_.get();
 }
 
 void ExtensionSystemImpl::RegisterExtensionWithRequestContexts(
     const Extension* extension) {
@@ skipping 14 matching lines @@
 void ExtensionSystemImpl::UnregisterExtensionWithRequestContexts(
     const std::string& extension_id,
     const extension_misc::UnloadedExtensionReason reason) {
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&ExtensionInfoMap::RemoveExtension, info_map(),
                  extension_id, reason));
 }
 
 }  // namespace extensions