Add detailed change event for SpecialStoragePolicy.

This change includes:
 - Split single Changed event to Granted, Revoked and Cleared events.
 - Add affected origin and changed policy as event parameters.

BUG=220029
TEST=ExtensionSetTest.*, *Quota*, ExtensionSpecialStoragePolicyTest.*

Review URL: https://chromiumcodereview.appspot.com/14238005

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@195478 0039d316-1c4b-4281-b951-d872f2087c98

3 files changed, 199 insertions, 75 deletions

diff --git a/chrome/browser/extensions/extension_special_storage_policy.cc b/chrome/browser/extensions/extension_special_storage_policy.cc
index 8714e3f..1f472fd 100644
--- a/chrome/browser/extensions/extension_special_storage_policy.cc
+++ b/chrome/browser/extensions/extension_special_storage_policy.cc
@@ -20,6 +20,8 @@
 
 using content::BrowserThread;
 using extensions::APIPermission;
+using extensions::Extension;
+using quota::SpecialStoragePolicy;
 
 ExtensionSpecialStoragePolicy::ExtensionSpecialStoragePolicy(
     CookieSettings* cookie_settings)
@@ -93,19 +95,28 @@ void ExtensionSpecialStoragePolicy::GrantRightsForExtension(
         extension->is_app())) {
     return;
   }
+
+  int change_flags = 0;
   {
     base::AutoLock locker(lock_);
-    if (NeedsProtection(extension))
-      protected_apps_.Add(extension);
+    if (NeedsProtection(extension) && protected_apps_.Add(extension))
+      change_flags |= SpecialStoragePolicy::STORAGE_PROTECTED;
     // FIXME: Does GrantRightsForExtension imply |extension| is installed?
     if (extension->is_app())
       installed_apps_.Add(extension);
-    if (extension->HasAPIPermission(APIPermission::kUnlimitedStorage))
-      unlimited_extensions_.Add(extension);
+
+    if (extension->HasAPIPermission(APIPermission::kUnlimitedStorage) &&
+        unlimited_extensions_.Add(extension))
+      change_flags |= SpecialStoragePolicy::STORAGE_UNLIMITED;
+
     if (extension->HasAPIPermission(APIPermission::kFileBrowserHandler))
       file_handler_extensions_.Add(extension);
   }
-  NotifyChanged();
+
+  if (change_flags) {
+    NotifyGranted(Extension::GetBaseURLFromExtensionId(extension->id()),
+                  change_flags);
+  }
 }
 
 void ExtensionSpecialStoragePolicy::RevokeRightsForExtension(
@@ -117,18 +128,27 @@ void ExtensionSpecialStoragePolicy::RevokeRightsForExtension(
         extension->is_app())) {
     return;
   }
+  int change_flags = 0;
   {
     base::AutoLock locker(lock_);
-    if (NeedsProtection(extension))
-      protected_apps_.Remove(extension);
+    if (NeedsProtection(extension) && protected_apps_.Remove(extension))
+      change_flags |= SpecialStoragePolicy::STORAGE_PROTECTED;
+
     if (extension->is_app())
       installed_apps_.Remove(extension);
-    if (extension->HasAPIPermission(APIPermission::kUnlimitedStorage))
-      unlimited_extensions_.Remove(extension);
+
+    if (extension->HasAPIPermission(APIPermission::kUnlimitedStorage) &&
+        unlimited_extensions_.Remove(extension))
+      change_flags |= SpecialStoragePolicy::STORAGE_UNLIMITED;
+
     if (extension->HasAPIPermission(APIPermission::kFileBrowserHandler))
       file_handler_extensions_.Remove(extension);
   }
-  NotifyChanged();
+
+  if (change_flags) {
+    NotifyRevoked(Extension::GetBaseURLFromExtensionId(extension->id()),
+                  change_flags);
+  }
 }
 
 void ExtensionSpecialStoragePolicy::RevokeRightsForAllExtensions() {
@@ -139,16 +159,44 @@ void ExtensionSpecialStoragePolicy::RevokeRightsForAllExtensions() {
     unlimited_extensions_.Clear();
     file_handler_extensions_.Clear();
   }
-  NotifyChanged();
+
+  NotifyCleared();
+}
+
+void ExtensionSpecialStoragePolicy::NotifyGranted(
+    const GURL& origin,
+    int change_flags) {
+  if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
+    BrowserThread::PostTask(
+        BrowserThread::IO, FROM_HERE,
+        base::Bind(&ExtensionSpecialStoragePolicy::NotifyGranted, this,
+                   origin, change_flags));
+    return;
+  }
+  SpecialStoragePolicy::NotifyGranted(origin, change_flags);
+}
+
+void ExtensionSpecialStoragePolicy::NotifyRevoked(
+    const GURL& origin,
+    int change_flags) {
+  if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
+    BrowserThread::PostTask(
+        BrowserThread::IO, FROM_HERE,
+        base::Bind(&ExtensionSpecialStoragePolicy::NotifyRevoked, this,
+                   origin, change_flags));
+    return;
+  }
+  SpecialStoragePolicy::NotifyRevoked(origin, change_flags);
 }
 
-void ExtensionSpecialStoragePolicy::NotifyChanged() {
+void ExtensionSpecialStoragePolicy::NotifyCleared() {
   if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
-    BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-        base::Bind(&ExtensionSpecialStoragePolicy::NotifyChanged, this));
+    BrowserThread::PostTask(
+        BrowserThread::IO, FROM_HERE,
+        base::Bind(&ExtensionSpecialStoragePolicy::NotifyCleared, this));
     return;
   }
-  SpecialStoragePolicy::NotifyObservers();
+  SpecialStoragePolicy::NotifyCleared();
 }
 
 //-----------------------------------------------------------------------------
@@ -188,16 +236,16 @@ bool ExtensionSpecialStoragePolicy::SpecialCollection::ContainsExtension(
   return extensions_.Contains(extension_id);
 }
 
-void ExtensionSpecialStoragePolicy::SpecialCollection::Add(
+bool ExtensionSpecialStoragePolicy::SpecialCollection::Add(
     const extensions::Extension* extension) {
   ClearCache();
-  extensions_.Insert(extension);
+  return extensions_.Insert(extension);
 }
 
-void ExtensionSpecialStoragePolicy::SpecialCollection::Remove(
+bool ExtensionSpecialStoragePolicy::SpecialCollection::Remove(
     const extensions::Extension* extension) {
   ClearCache();
-  extensions_.Remove(extension->id());
+  return extensions_.Remove(extension->id());
 }
 
 void ExtensionSpecialStoragePolicy::SpecialCollection::Clear() {
diff --git a/chrome/browser/extensions/extension_special_storage_policy.h b/chrome/browser/extensions/extension_special_storage_policy.h
index 1bf34e8..c8ebe51 100644
--- a/chrome/browser/extensions/extension_special_storage_policy.h
+++ b/chrome/browser/extensions/extension_special_storage_policy.h
@@ -59,8 +59,8 @@ class ExtensionSpecialStoragePolicy : public quota::SpecialStoragePolicy {
     bool Contains(const GURL& origin);
     const ExtensionSet* ExtensionsContaining(const GURL& origin);
     bool ContainsExtension(const std::string& extension_id);
-    void Add(const extensions::Extension* extension);
-    void Remove(const extensions::Extension* extension);
+    bool Add(const extensions::Extension* extension);
+    bool Remove(const extensions::Extension* extension);
     void Clear();
 
    private:
@@ -72,7 +72,9 @@ class ExtensionSpecialStoragePolicy : public quota::SpecialStoragePolicy {
     CachedResults cached_results_;
   };
 
-  void NotifyChanged();
+  void NotifyGranted(const GURL& origin, int change_flags);
+  void NotifyRevoked(const GURL& origin, int change_flags);
+  void NotifyCleared();
 
   base::Lock lock_;  // Synchronize all access to the collections.
   SpecialCollection protected_apps_;
diff --git a/chrome/browser/extensions/extension_special_storage_policy_unittest.cc b/chrome/browser/extensions/extension_special_storage_policy_unittest.cc
index ebd5787..2b592a3 100644
--- a/chrome/browser/extensions/extension_special_storage_policy_unittest.cc
+++ b/chrome/browser/extensions/extension_special_storage_policy_unittest.cc
@@ -20,12 +20,79 @@
 using content::BrowserThread;
 using extensions::Extension;
 using extensions::Manifest;
+using quota::SpecialStoragePolicy;
+
+typedef SpecialStoragePolicy::StoragePolicy StoragePolicy;
 
 namespace keys = extension_manifest_keys;
 
 class ExtensionSpecialStoragePolicyTest : public extensions::ExtensionTest {
  protected:
-  virtual void SetUp() {
+  class PolicyChangeObserver : public SpecialStoragePolicy::Observer {
+   public:
+    PolicyChangeObserver()
+        : expected_type_(NOTIFICATION_TYPE_NONE),
+          expected_change_flags_(0) {
+    }
+
+    virtual void OnGranted(const GURL& origin,
+                           int change_flags) OVERRIDE {
+      EXPECT_EQ(expected_type_, NOTIFICATION_TYPE_GRANT);
+      EXPECT_EQ(expected_origin_, origin);
+      EXPECT_EQ(expected_change_flags_, change_flags);
+      expected_type_ = NOTIFICATION_TYPE_NONE;
+    }
+
+    virtual void OnRevoked(const GURL& origin,
+                           int change_flags) OVERRIDE {
+      EXPECT_EQ(expected_type_, NOTIFICATION_TYPE_REVOKE);
+      EXPECT_EQ(expected_origin_, origin);
+      EXPECT_EQ(expected_change_flags_, change_flags);
+      expected_type_ = NOTIFICATION_TYPE_NONE;
+    }
+
+    virtual void OnCleared() OVERRIDE {
+      EXPECT_EQ(expected_type_, NOTIFICATION_TYPE_CLEAR);
+      expected_type_ = NOTIFICATION_TYPE_NONE;
+    }
+
+    void ExpectGrant(const std::string& extension_id,
+                     int change_flags) {
+      expected_type_ = NOTIFICATION_TYPE_GRANT;
+      expected_origin_ = Extension::GetBaseURLFromExtensionId(extension_id);
+      expected_change_flags_ = change_flags;
+    }
+
+    void ExpectRevoke(const std::string& extension_id,
+                      int change_flags) {
+      expected_type_ = NOTIFICATION_TYPE_REVOKE;
+      expected_origin_ = Extension::GetBaseURLFromExtensionId(extension_id);
+      expected_change_flags_ = change_flags;
+    }
+
+    void ExpectClear() {
+      expected_type_ = NOTIFICATION_TYPE_CLEAR;
+    }
+
+    bool IsCompleted() {
+      return expected_type_ == NOTIFICATION_TYPE_NONE;
+    }
+
+   private:
+    enum {
+      NOTIFICATION_TYPE_NONE,
+      NOTIFICATION_TYPE_GRANT,
+      NOTIFICATION_TYPE_REVOKE,
+      NOTIFICATION_TYPE_CLEAR,
+    } expected_type_;
+
+    GURL expected_origin_;
+    int expected_change_flags_;
+
+    DISALLOW_COPY_AND_ASSIGN(PolicyChangeObserver);
+  };
+
+  virtual void SetUp() OVERRIDE {
     extensions::ExtensionTest::SetUp();
     policy_ = new ExtensionSpecialStoragePolicy(NULL);
   }
@@ -77,58 +144,6 @@ class ExtensionSpecialStoragePolicyTest : public extensions::ExtensionTest {
     return unlimited_app;
   }
 
-  scoped_refptr<Extension> CreateComponentApp() {
-#if defined(OS_WIN)
-    base::FilePath path(FILE_PATH_LITERAL("c:\\component"));
-#elif defined(OS_POSIX)
-    base::FilePath path(FILE_PATH_LITERAL("/component"));
-#endif
-    DictionaryValue manifest;
-    manifest.SetString(keys::kName, "Component");
-    manifest.SetString(keys::kVersion, "1");
-    manifest.SetString(keys::kPublicKey,
-        "MIGdMA0GCSqGSIb3DQEBAQUAA4GLADCBhwKBgQDOuXEIuoK1kAkBe0SKiJn/N9oNn3oU" \
-        "xGa4dwj40MnJqPn+w0aR2vuyocm0R4Drp67aYwtLjOVPF4CICRq6ICP6eU07gGwQxGdZ" \
-        "7HJASXV8hm0tab5I70oJmRLfFJyVAMCeWlFaOGq05v2i6EbifZM0qO5xALKNGQt+yjXi" \
-        "5INM5wIBIw==");
-    ListValue* list = new ListValue();
-    list->Append(Value::CreateStringValue("unlimitedStorage"));
-    list->Append(Value::CreateStringValue("fileSystem"));
-    list->Append(Value::CreateStringValue("fileBrowserPrivate"));
-    manifest.Set(keys::kPermissions, list);
-    std::string error;
-    scoped_refptr<Extension> component_app = Extension::Create(
-        path, Manifest::COMPONENT, manifest, Extension::NO_FLAGS, &error);
-    EXPECT_TRUE(component_app.get()) << error;
-    return component_app;
-  }
-
-  scoped_refptr<Extension> CreateHandlerApp() {
-#if defined(OS_WIN)
-    base::FilePath path(FILE_PATH_LITERAL("c:\\handler"));
-#elif defined(OS_POSIX)
-    base::FilePath path(FILE_PATH_LITERAL("/handler"));
-#endif
-    DictionaryValue manifest;
-    manifest.SetString(keys::kName, "Handler");
-    manifest.SetString(keys::kVersion, "1");
-    manifest.SetString(keys::kPublicKey,
-        "MIGdMA0GCSqGSIb3DQEBAQUAA4GLADCBhwKBgQChptAQ0n4R56N03nWQ1ogR7DVRBjGo" \
-        "80Vw6G9KLjzZv44D8rq5Q5IkeQrtKgWyZfXevlsCe3LaLo18rcz8iZx6lK2xhLdUR+OR" \
-        "jsjuBfdEL5a5cWeRTSxf75AcqndQsmpwMBdrMTCZ8jQNusUI+XlrihLNNJuI5TM4vNIN" \
-        "I5bYFQIBIw==");
-    ListValue* list = new ListValue();
-    list->Append(Value::CreateStringValue("unlimitedStorage"));
-    list->Append(Value::CreateStringValue("fileSystem"));
-    manifest.Set(keys::kPermissions, list);
-    std::string error;
-    scoped_refptr<Extension> handler_app = Extension::Create(
-        path, Manifest::INVALID_LOCATION, manifest,
-        Extension::NO_FLAGS, &error);
-    EXPECT_TRUE(handler_app.get()) << error;
-    return handler_app;
-  }
-
   scoped_refptr<Extension> CreateRegularApp() {
 #if defined(OS_WIN)
     base::FilePath path(FILE_PATH_LITERAL("c:\\app"));
@@ -321,3 +336,62 @@ TEST_F(ExtensionSpecialStoragePolicyTest, HasSessionOnlyOrigins) {
 
   EXPECT_FALSE(policy_->HasSessionOnlyOrigins());
 }
+
+TEST_F(ExtensionSpecialStoragePolicyTest, NotificationTest) {
+  MessageLoop message_loop;
+  content::TestBrowserThread ui_thread(BrowserThread::UI, &message_loop);
+  content::TestBrowserThread io_thread(BrowserThread::IO, &message_loop);
+
+  PolicyChangeObserver observer;
+  policy_->AddObserver(&observer);
+
+  scoped_refptr<Extension> apps[] = {
+    CreateProtectedApp(),
+    CreateUnlimitedApp(),
+  };
+
+  int change_flags[] = {
+    SpecialStoragePolicy::STORAGE_PROTECTED,
+
+    SpecialStoragePolicy::STORAGE_PROTECTED |
+    SpecialStoragePolicy::STORAGE_UNLIMITED,
+  };
+
+  ASSERT_EQ(arraysize(apps), arraysize(change_flags));
+  for (size_t i = 0; i < arraysize(apps); ++i) {
+    SCOPED_TRACE(testing::Message() << "i: " << i);
+    observer.ExpectGrant(apps[i]->id(), change_flags[i]);
+    policy_->GrantRightsForExtension(apps[i]);
+    message_loop.RunUntilIdle();
+    EXPECT_TRUE(observer.IsCompleted());
+  }
+
+  for (size_t i = 0; i < arraysize(apps); ++i) {
+    SCOPED_TRACE(testing::Message() << "i: " << i);
+    policy_->GrantRightsForExtension(apps[i]);
+    message_loop.RunUntilIdle();
+    EXPECT_TRUE(observer.IsCompleted());
+  }
+
+  for (size_t i = 0; i < arraysize(apps); ++i) {
+    SCOPED_TRACE(testing::Message() << "i: " << i);
+    observer.ExpectRevoke(apps[i]->id(), change_flags[i]);
+    policy_->RevokeRightsForExtension(apps[i]);
+    message_loop.RunUntilIdle();
+    EXPECT_TRUE(observer.IsCompleted());
+  }
+
+  for (size_t i = 0; i < arraysize(apps); ++i) {
+    SCOPED_TRACE(testing::Message() << "i: " << i);
+    policy_->RevokeRightsForExtension(apps[i]);
+    message_loop.RunUntilIdle();
+    EXPECT_TRUE(observer.IsCompleted());
+  }
+
+  observer.ExpectClear();
+  policy_->RevokeRightsForAllExtensions();
+  message_loop.RunUntilIdle();
+  EXPECT_TRUE(observer.IsCompleted());
+
+  policy_->RemoveObserver(&observer);
+}