Remove //chrome dependency from ExtensionPrefs

extensions/browser/extension_prefs.cc

 // Copyright 2014 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 "extensions/browser/extension_prefs.h"
 
 #include <iterator>
 
 #include "base/command_line.h"
 #include "base/prefs/pref_notifier.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/value_conversions.h"
-#include "chrome/browser/extensions/api/content_settings/content_settings_store.h"
 #include "components/user_prefs/pref_registry_syncable.h"
 #include "extensions/browser/admin_policy.h"
 #include "extensions/browser/app_sorting.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_pref_store.h"
 #include "extensions/browser/extension_prefs_factory.h"
+#include "extensions/browser/extension_prefs_observer.h"
 #include "extensions/browser/pref_names.h"
 #include "extensions/common/feature_switch.h"
 #include "extensions/common/manifest.h"
 #include "extensions/common/permissions/permission_set.h"
 #include "extensions/common/permissions/permissions_info.h"
 #include "extensions/common/url_pattern.h"
 #include "extensions/common/user_script.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using base::Value;
@@ skipping 219 matching lines @@
   if (!source_dict->GetDictionary(key, &preferences))
     return;
 
   for (base::DictionaryValue::Iterator iter(*preferences); !iter.IsAtEnd();
        iter.Advance()) {
     value_map->SetExtensionPref(
         extension_id, iter.key(), scope, iter.value().DeepCopy());
   }
 }
 
-void InitExtensionControlledPrefs(ExtensionPrefs* prefs,
-                                  ExtensionPrefValueMap* value_map) {
-  ExtensionIdList extension_ids;
-  prefs->GetExtensions(&extension_ids);
-
-  for (ExtensionIdList::iterator extension_id = extension_ids.begin();
-       extension_id != extension_ids.end();
-       ++extension_id) {
-    base::Time install_time = prefs->GetInstallTime(*extension_id);
-    bool is_enabled = !prefs->IsExtensionDisabled(*extension_id);
-    bool is_incognito_enabled = prefs->IsIncognitoEnabled(*extension_id);
-    value_map->RegisterExtension(
-        *extension_id, install_time, is_enabled, is_incognito_enabled);
-    prefs->content_settings_store()->RegisterExtension(
-        *extension_id, install_time, is_enabled);
-
-    // Set regular extension controlled prefs.
-    LoadExtensionControlledPrefs(
-        prefs, value_map, *extension_id, kExtensionPrefsScopeRegular);
-    // Set incognito extension controlled prefs.
-    LoadExtensionControlledPrefs(prefs,
-                                 value_map,
-                                 *extension_id,
-                                 kExtensionPrefsScopeIncognitoPersistent);
-    // Set regular-only extension controlled prefs.
-    LoadExtensionControlledPrefs(
-        prefs, value_map, *extension_id, kExtensionPrefsScopeRegularOnly);
-
-    // Set content settings.
-    const base::ListValue* content_settings = NULL;
-    if (prefs->ReadPrefAsList(*extension_id,
-                              pref_names::kPrefContentSettings,
-                              &content_settings)) {
-      prefs->content_settings_store()->SetExtensionContentSettingFromList(
-          *extension_id, content_settings, kExtensionPrefsScopeRegular);
-    }
-    if (prefs->ReadPrefAsList(*extension_id,
-                              pref_names::kPrefIncognitoContentSettings,
-                              &content_settings)) {
-      prefs->content_settings_store()->SetExtensionContentSettingFromList(
-          *extension_id,
-          content_settings,
-          kExtensionPrefsScopeIncognitoPersistent);
-    }
-  }
-}
-
 }  // namespace
 
 //
 // TimeProvider
 //
 
 ExtensionPrefs::TimeProvider::TimeProvider() {
 }
 
 ExtensionPrefs::TimeProvider::~TimeProvider() {
@@ skipping 64 matching lines @@
 //
 // ExtensionPrefs
 //
 
 // static
 ExtensionPrefs* ExtensionPrefs::Create(
     PrefService* prefs,
     const base::FilePath& root_dir,
     ExtensionPrefValueMap* extension_pref_value_map,
     scoped_ptr<AppSorting> app_sorting,
-    bool extensions_disabled) {
+    bool extensions_disabled,
+    const std::vector<ExtensionPrefsObserver*>& early_observers) {
   return ExtensionPrefs::Create(prefs,
                                 root_dir,
                                 extension_pref_value_map,
                                 app_sorting.Pass(),
                                 extensions_disabled,
+                                early_observers,
                                 make_scoped_ptr(new TimeProvider()));
 }
 
 // static
 ExtensionPrefs* ExtensionPrefs::Create(
     PrefService* pref_service,
     const base::FilePath& root_dir,
     ExtensionPrefValueMap* extension_pref_value_map,
     scoped_ptr<AppSorting> app_sorting,
     bool extensions_disabled,
+    const std::vector<ExtensionPrefsObserver*>& early_observers,
     scoped_ptr<TimeProvider> time_provider) {
   return new ExtensionPrefs(pref_service,
                             root_dir,
                             extension_pref_value_map,
                             app_sorting.Pass(),
                             time_provider.Pass(),
-                            extensions_disabled);
+                            extensions_disabled,
+                            early_observers);
 }
 
 ExtensionPrefs::~ExtensionPrefs() {
 }
 
 // static
 ExtensionPrefs* ExtensionPrefs::Get(content::BrowserContext* context) {
   return ExtensionPrefsFactory::GetInstance()->GetForBrowserContext(context);
 }
 
@@ skipping 78 matching lines @@
   }
   ScopedExtensionPrefUpdate update(prefs_, extension_id);
   if (data_value)
     update->Set(key, data_value);
   else
     update->Remove(key, NULL);
 }
 
 void ExtensionPrefs::DeleteExtensionPrefs(const std::string& extension_id) {
   extension_pref_value_map_->UnregisterExtension(extension_id);
-  content_settings_store_->UnregisterExtension(extension_id);
+  FOR_EACH_OBSERVER(ExtensionPrefsObserver,
+                    observer_list_,
+                    OnExtensionPrefsDeleted(extension_id));
   DictionaryPrefUpdate update(prefs_, pref_names::kExtensions);
   base::DictionaryValue* dict = update.Get();
   dict->Remove(extension_id, NULL);
 }
 
 bool ExtensionPrefs::ReadPrefAsBoolean(const std::string& extension_id,
                                        const std::string& pref_key,
                                        bool* out_value) const {
   const base::DictionaryValue* ext = GetExtensionPref(extension_id);
   if (!ext || !ext->GetBoolean(pref_key, out_value))
@@ skipping 326 matching lines @@
     return;
 
   if (new_value == Extension::DISABLE_NONE) {
     UpdateExtensionPref(extension_id, kPrefDisableReasons, NULL);
   } else {
     UpdateExtensionPref(extension_id,
                         kPrefDisableReasons,
                         new base::FundamentalValue(new_value));
   }
 
-  FOR_EACH_OBSERVER(Observer,
+  FOR_EACH_OBSERVER(ExtensionPrefsObserver,
                     observer_list_,
                     OnExtensionDisableReasonsChanged(extension_id, new_value));
 }
 
 std::set<std::string> ExtensionPrefs::GetBlacklistedExtensions() {
   std::set<std::string> ids;
 
   const base::DictionaryValue* extensions =
       prefs_->GetDictionary(pref_names::kExtensions);
   if (!extensions)
@@ skipping 379 matching lines @@
 
   // For external extensions, we save a preference reminding ourself not to try
   // and install the extension anymore (except when |external_uninstall| is
   // true, which signifies that the registry key was deleted or the pref file
   // no longer lists the extension).
   if (!external_uninstall && Manifest::IsExternalLocation(location)) {
     UpdateExtensionPref(extension_id, kPrefState,
                         new base::FundamentalValue(
                             Extension::EXTERNAL_EXTENSION_UNINSTALLED));
     extension_pref_value_map_->SetExtensionState(extension_id, false);
-    content_settings_store_->SetExtensionState(extension_id, false);
+    FOR_EACH_OBSERVER(ExtensionPrefsObserver,
+                      observer_list_,
+                      OnExtensionStateChanged(extension_id, false));
   } else {
     int creation_flags = GetCreationFlags(extension_id);
     if (creation_flags & Extension::IS_EPHEMERAL) {
       // Keep ephemeral apps around, but mark them as evicted.
       UpdateExtensionPref(extension_id, kPrefEvictedEphemeralApp,
                           new base::FundamentalValue(true));
     } else {
       DeleteExtensionPrefs(extension_id);
     }
   }
 }
 
 void ExtensionPrefs::SetExtensionState(const std::string& extension_id,
                                        Extension::State state) {
   UpdateExtensionPref(extension_id, kPrefState,
                       new base::FundamentalValue(state));
   bool enabled = (state == Extension::ENABLED);
   extension_pref_value_map_->SetExtensionState(extension_id, enabled);
-  content_settings_store_->SetExtensionState(extension_id, enabled);
+  FOR_EACH_OBSERVER(ExtensionPrefsObserver,
+                    observer_list_,
+                    OnExtensionStateChanged(extension_id, enabled));
 }
 
 void ExtensionPrefs::SetExtensionBlacklistState(const std::string& extension_id,
                                                 BlacklistState state) {
   SetExtensionBlacklisted(extension_id, state == BLACKLISTED_MALWARE);
   UpdateExtensionPref(extension_id, kPrefBlacklistState,
                       new base::FundamentalValue(state));
 }
 
 BlacklistState ExtensionPrefs::GetExtensionBlacklistState(
@@ skipping 478 matching lines @@
     if (!it.value().GetAsDictionary(&ext)) {
       NOTREACHED() << "Invalid pref for extension " << it.key();
       continue;
     }
     if (!IsBlacklistBitSet(ext))
       result.push_back(it.key());
   }
   return result;
 }
 
-void ExtensionPrefs::AddObserver(Observer* observer) {
+void ExtensionPrefs::AddObserver(ExtensionPrefsObserver* observer) {
   observer_list_.AddObserver(observer);
 }
 
-void ExtensionPrefs::RemoveObserver(Observer* observer) {
+void ExtensionPrefs::RemoveObserver(ExtensionPrefsObserver* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
 void ExtensionPrefs::FixMissingPrefs(const ExtensionIdList& extension_ids) {
   // Fix old entries that did not get an installation time entry when they
   // were installed or don't have a preferences field.
   for (ExtensionIdList::const_iterator ext_id = extension_ids.begin();
        ext_id != extension_ids.end(); ++ext_id) {
     if (GetInstallTime(*ext_id) == base::Time()) {
       VLOG(1) << "Could not parse installation time of extension "
@@ skipping 26 matching lines @@
     ScopedExtensionPrefUpdate update(prefs_, *ext_id);
     // This creates an empty dictionary if none is stored.
     update.Get();
   }
 
   FixMissingPrefs(extension_ids);
   MigratePermissions(extension_ids);
   MigrateDisableReasons(extension_ids);
   app_sorting_->Initialize(extension_ids);
 
-  InitExtensionControlledPrefs(this, extension_pref_value_map_);
+  InitExtensionControlledPrefs(extension_pref_value_map_);
 
   extension_pref_value_map_->NotifyInitializationCompleted();
 }
 
 bool ExtensionPrefs::HasIncognitoPrefValue(const std::string& pref_key) {
   bool has_incognito_pref_value = false;
   extension_pref_value_map_->GetEffectivePrefValue(pref_key,
                                                    true,
                                                    &has_incognito_pref_value);
   return has_incognito_pref_value;
@@ skipping 73 matching lines @@
                       kPrefInstallParam,
                       new base::StringValue(install_parameter));
 }
 
 ExtensionPrefs::ExtensionPrefs(
     PrefService* prefs,
     const base::FilePath& root_dir,
     ExtensionPrefValueMap* extension_pref_value_map,
     scoped_ptr<AppSorting> app_sorting,
     scoped_ptr<TimeProvider> time_provider,
-    bool extensions_disabled)
+    bool extensions_disabled,
+    const std::vector<ExtensionPrefsObserver*>& early_observers)
     : prefs_(prefs),
       install_directory_(root_dir),
       extension_pref_value_map_(extension_pref_value_map),
       app_sorting_(app_sorting.Pass()),
-      content_settings_store_(new ContentSettingsStore()),
       time_provider_(time_provider.Pass()),
       extensions_disabled_(extensions_disabled) {
   app_sorting_->SetExtensionScopedPrefs(this);
   MakePathsRelative();
+
+  // Ensure that any early observers are watching before prefs are initialized.
+  for (std::vector<ExtensionPrefsObserver*>::const_iterator iter =
+           early_observers.begin();
+       iter != early_observers.end();
+       ++iter) {
+    AddObserver(*iter);
+  }
+
   InitPrefStore();
 }
 
 void ExtensionPrefs::SetNeedsStorageGarbageCollection(bool value) {
   prefs_->SetBoolean(pref_names::kStorageGarbageCollect, value);
 }
 
 bool ExtensionPrefs::NeedsStorageGarbageCollection() {
   return prefs_->GetBoolean(pref_names::kStorageGarbageCollect);
 }
@@ skipping 141 matching lines @@
                         new base::StringValue(install_parameter));
   }
   // We store prefs about LOAD extensions, but don't cache their manifest
   // since it may change on disk.
   if (!Manifest::IsUnpackedLocation(extension->location())) {
     extension_dict->Set(kPrefManifest,
                         extension->manifest()->value()->DeepCopy());
   }
 }
 
+void ExtensionPrefs::InitExtensionControlledPrefs(
+    ExtensionPrefValueMap* value_map) {
+  ExtensionIdList extension_ids;
+  GetExtensions(&extension_ids);
+
+  for (ExtensionIdList::iterator extension_id = extension_ids.begin();
+       extension_id != extension_ids.end();
+       ++extension_id) {
+    base::Time install_time = GetInstallTime(*extension_id);
+    bool is_enabled = !IsExtensionDisabled(*extension_id);
+    bool is_incognito_enabled = IsIncognitoEnabled(*extension_id);
+    value_map->RegisterExtension(
+        *extension_id, install_time, is_enabled, is_incognito_enabled);
+
+    FOR_EACH_OBSERVER(
+        ExtensionPrefsObserver,
+        observer_list_,
+        OnExtensionRegistered(*extension_id, install_time, is_enabled));
+
+    // Set regular extension controlled prefs.
+    LoadExtensionControlledPrefs(
+        this, value_map, *extension_id, kExtensionPrefsScopeRegular);
+    // Set incognito extension controlled prefs.
+    LoadExtensionControlledPrefs(this,
+                                 value_map,
+                                 *extension_id,
+                                 kExtensionPrefsScopeIncognitoPersistent);
+    // Set regular-only extension controlled prefs.
+    LoadExtensionControlledPrefs(
+        this, value_map, *extension_id, kExtensionPrefsScopeRegularOnly);
+
+    FOR_EACH_OBSERVER(ExtensionPrefsObserver,
+                      observer_list_,
+                      OnExtensionPrefsLoaded(*extension_id, this));
+  }
+}
+
 void ExtensionPrefs::FinishExtensionInfoPrefs(
     const std::string& extension_id,
     const base::Time install_time,
     bool needs_sort_ordinal,
     const syncer::StringOrdinal& suggested_page_ordinal,
     base::DictionaryValue* extension_dict) {
   // Reinitializes various preferences with empty dictionaries.
   if (!extension_dict->HasKey(pref_names::kPrefPreferences)) {
     extension_dict->Set(pref_names::kPrefPreferences,
                         new base::DictionaryValue);
@@ skipping 21 matching lines @@
   // out of date.
   extension_dict->Remove(kDelayedInstallInfo, NULL);
 
   // Clear state that may be registered from a previous install.
   extension_dict->Remove(EventRouter::kRegisteredEvents, NULL);
 
   // When evicted ephemeral apps are re-installed, this flag must be reset.
   extension_dict->Remove(kPrefEvictedEphemeralApp, NULL);
 
   // FYI, all code below here races on sudden shutdown because |extension_dict|,
-  // |app_sorting_|, |extension_pref_value_map_|, and |content_settings_store_|
+  // |app_sorting_|, |extension_pref_value_map_|, and (potentially) observers
   // are updated non-transactionally. This is probably not fixable without
   // nested transactional updates to pref dictionaries.
   if (needs_sort_ordinal)
     app_sorting_->EnsureValidOrdinals(extension_id, suggested_page_ordinal);
 
   bool is_enabled = false;
   int initial_state;
   if (extension_dict->GetInteger(kPrefState, &initial_state)) {
     is_enabled = initial_state == Extension::ENABLED;
   }
   bool is_incognito_enabled = IsIncognitoEnabled(extension_id);
 
   extension_pref_value_map_->RegisterExtension(
       extension_id, install_time, is_enabled, is_incognito_enabled);
-  content_settings_store_->RegisterExtension(extension_id, install_time,
-                                             is_enabled);
+
+  FOR_EACH_OBSERVER(
+      ExtensionPrefsObserver,
+      observer_list_,
+      OnExtensionRegistered(extension_id, install_time, is_enabled));
 }
 
 }  // namespace extensions