Refactor and fix declarative webRequest API permissions

chrome/browser/extensions/api/declarative/rules_registry_storage_delegate.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/api/declarative/rules_registry_storage_delegate.h"
 
 #include "base/bind.h"
+#include "chrome/browser/extensions/extension_info_map.h"
+#include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/state_store.h"
+#include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 
 namespace extensions {
 
 namespace {
 
@@ skipping 37 matching lines @@
   Inner(Profile* profile,
         RulesRegistryWithCache* rules_registry,
         const std::string& storage_key);
 
  private:
   friend class base::RefCountedThreadSafe<Inner>;
   friend class RulesRegistryStorageDelegate;
 
   ~Inner();
 
+  // Initialization of the storage delegate if it is used in the context of
+  // an incognito profile.
+  void InitForOTRProfile();
+
   // NotificationObserver
   virtual void Observe(
       int type,
       const content::NotificationSource& source,
       const content::NotificationDetails& details) OVERRIDE;
 
   // Read/write a list of rules serialized to Values.
   void ReadFromStorage(const std::string& extension_id);
   void ReadFromStorageCallback(const std::string& extension_id,
                        scoped_ptr<base::Value> value);
@@ skipping 80 matching lines @@
 RulesRegistryStorageDelegate::Inner::Inner(
     Profile* profile,
     RulesRegistryWithCache* rules_registry,
     const std::string& storage_key)
     : registrar_(new content::NotificationRegistrar()),
       profile_(profile),
       storage_key_(storage_key),
       rules_registry_thread_(rules_registry->GetOwnerThread()),
       rules_registry_(rules_registry),
       ready_(false) {
-  registrar_->Add(this, chrome::NOTIFICATION_EXTENSION_LOADED,
-                  content::Source<Profile>(profile));
-  registrar_->Add(this, chrome::NOTIFICATION_EXTENSIONS_READY,
-                  content::Source<Profile>(profile));
+  if (!profile_->IsOffTheRecord()) {
+    registrar_->Add(this, chrome::NOTIFICATION_EXTENSION_LOADED,
+                    content::Source<Profile>(profile));
+    registrar_->Add(this, chrome::NOTIFICATION_EXTENSIONS_READY,
+                    content::Source<Profile>(profile));
+  } else {
+    registrar_->Add(this, chrome::NOTIFICATION_EXTENSION_LOADED,
+                    content::Source<Profile>(profile->GetOriginalProfile()));
+    InitForOTRProfile();
+  }
 }
 
 RulesRegistryStorageDelegate::Inner::~Inner() {
   DCHECK(!registrar_.get());
 }
 
+void RulesRegistryStorageDelegate::Inner::InitForOTRProfile() {
+  ExtensionService* extension_service =
+      extensions::ExtensionSystem::Get(profile_)->extension_service();
+  const ExtensionSet* extensions = extension_service->extensions();
+  for (ExtensionSet::const_iterator i = extensions->begin();
+       i != extensions->end(); ++i) {
+    if ((*i)->HasAPIPermission(APIPermission::kDeclarativeWebRequest) &&
+        extension_service->IsIncognitoEnabled((*i)->id()))
+      ReadFromStorage((*i)->id());
+  }
+  ready_ = true;
+}
+
 void RulesRegistryStorageDelegate::Inner::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   if (type == chrome::NOTIFICATION_EXTENSION_LOADED) {
     const extensions::Extension* extension =
         content::Details<const extensions::Extension>(details).ptr();
     // TODO(mpcomplete): This API check should generalize to any use of
     // declarative rules, not just webRequest.
     if (extension->HasAPIPermission(
             APIPermission::kDeclarativeWebRequest)) {
-      ReadFromStorage(extension->id());
+      ExtensionInfoMap* extension_info_map =
+          ExtensionSystem::Get(profile_)->info_map();
+      if (profile_->IsOffTheRecord() &&
+          !extension_info_map->IsIncognitoEnabled(extension->id())) {
+        // Ignore this extension.
+      } else {
+        ReadFromStorage(extension->id());
+      }
     }
   } else if (type == chrome::NOTIFICATION_EXTENSIONS_READY) {
     CheckIfReady();
   }
 }
 
 void RulesRegistryStorageDelegate::Inner::ReadFromStorage(
     const std::string& extension_id) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   extensions::StateStore* store = ExtensionSystem::Get(profile_)->state_store();
@@ skipping 46 matching lines @@
 void RulesRegistryStorageDelegate::Inner::NotifyReadyOnRegistryThread() {
   DCHECK(content::BrowserThread::CurrentlyOn(rules_registry_thread_));
   if (ready_)
     return;  // we've already notified our readiness
 
   ready_ = true;
   rules_registry_->OnReady();
 }
 
 }  // namespace extensions