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_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));

[Matt Perry, 2012/07/25 21:27:56]

You need to register for the notification for profile->GetOriginalProfile()

[Yoyo Zhou, 2012/07/25 21:44:45]

You probably want profile->GetOriginalProfile() here.

[battre, 2012/07/26 16:38:43]

Done.

[battre, 2012/07/26 16:38:43]

Done.

+    InitForOTRProfile();

[Matt Perry, 2012/07/25 21:27:56]

You should also set ready_ = true.

[battre, 2012/07/26 16:38:43]

I think the better approach is to call CheckIfReady here. Do you agree?

[Matt Perry, 2012/07/26 18:42:41]

No, then it will be considered "not ready" for some amount of time. The
incognito version starts ready, so it doesn't actually need to notify the rules
registry.

+  }
 }
 
 RulesRegistryStorageDelegate::Inner::~Inner() {
   DCHECK(!registrar_.get());
 }
 
+void RulesRegistryStorageDelegate::Inner::InitForOTRProfile() {

[Matt Perry, 2012/07/25 21:27:56]

May as well do this step for both types of profiles. Just check if the
extension_service is loaded, and if so, do this step.

[battre, 2012/07/26 16:38:43]

This is not quite clear to me. Note the check whether the extension is enabled
in incognito mode in line 196.

[Matt Perry, 2012/07/26 18:42:41]

OK, I take that back then.

+  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());
+  }
+}
+
 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.
@@ skipping 59 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