Move Extension Location and Type enums to Manifest, and move InstallWarning to its own file.

chrome/browser/extensions/extension_prefs.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_prefs.h"
 
 #include "base/command_line.h"
 #include "base/prefs/pref_notifier.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
@@ skipping 25 matching lines @@
 
 namespace extensions {
 
 namespace {
 
 // Additional preferences keys
 
 // Whether this extension was running when chrome last shutdown.
 const char kPrefRunning[] = "running";
 
-// Where an extension was installed from. (see Extension::Location)
+// Where an extension was installed from. (see Manifest::Location)
 const char kPrefLocation[] = "location";
 
 // Enabled, disabled, killed, etc. (see Extension::State)
 const char kPrefState[] = "state";
 
 // The path to the current version's manifest file.
 const char kPrefPath[] = "path";
 
 // The dictionary containing the extension's manifest.
 const char kPrefManifest[] = "manifest";
@@ skipping 366 matching lines @@
 
   // Collect all extensions ids with absolute paths in |absolute_keys|.
   std::set<std::string> absolute_keys;
   for (DictionaryValue::key_iterator i = dict->begin_keys();
        i != dict->end_keys(); ++i) {
     const DictionaryValue* extension_dict = NULL;
     if (!dict->GetDictionaryWithoutPathExpansion(*i, &extension_dict))
       continue;
     int location_value;
     if (extension_dict->GetInteger(kPrefLocation, &location_value) &&
-        location_value == Extension::LOAD) {
+        location_value == Manifest::LOAD) {
       // Unpacked extensions can have absolute paths.
       continue;
     }
     FilePath::StringType path_string;
     if (!extension_dict->GetString(kPrefPath, &path_string))
       continue;
     FilePath path(path_string);
     if (path.IsAbsolute())
       absolute_keys.insert(*i);
   }
@@ skipping 994 matching lines @@
   DictionaryValue* extension_dict = update.Get();
   const base::Time install_time = time_provider_->GetCurrentTime();
   PopulateExtensionInfoPrefs(extension, install_time, initial_state,
                              extension_dict);
   FinishExtensionInfoPrefs(extension->id(), install_time,
                            extension->RequiresSortOrdinal(),
                            page_ordinal, extension_dict);
 }
 
 void ExtensionPrefs::OnExtensionUninstalled(const std::string& extension_id,
-                                            const Extension::Location& location,
+                                            const Manifest::Location& location,
                                             bool external_uninstall) {
   extension_sorting_->ClearOrdinals(extension_id);
 
   // 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 && Extension::IsExternalLocation(location)) {
+  if (!external_uninstall && Manifest::IsExternalLocation(location)) {
     UpdateExtensionPref(extension_id, kPrefState,
                         Value::CreateIntegerValue(
                             Extension::EXTERNAL_EXTENSION_UNINSTALLED));
     extension_pref_value_map_->SetExtensionState(extension_id, false);
     content_settings_store_->SetExtensionState(extension_id, false);
   } else {
     DeleteExtensionPrefs(extension_id);
   }
 }
 
@@ skipping 50 matching lines @@
   std::string version;
   if (!extension->GetString(kPrefVersion, &version)) {
     LOG(ERROR) << "Bad or missing pref 'version' for extension '"
                << extension_id << "'";
   }
 
   return version;
 }
 
 void ExtensionPrefs::UpdateManifest(const Extension* extension) {
-  if (extension->location() != Extension::LOAD) {
+  if (extension->location() != Manifest::LOAD) {
     const DictionaryValue* extension_dict = GetExtensionPref(extension->id());
     if (!extension_dict)
       return;
     const DictionaryValue* old_manifest = NULL;
     bool update_required =
         !extension_dict->GetDictionary(kPrefManifest, &old_manifest) ||
         !extension->manifest()->value()->Equals(old_manifest);
     if (update_required) {
       UpdateExtensionPref(extension->id(), kPrefManifest,
                           extension->manifest()->value()->DeepCopy());
@@ skipping 67 matching lines @@
   FilePath::StringType path;
   int location_value;
   if (!ext->GetInteger(kPrefLocation, &location_value))
     return scoped_ptr<ExtensionInfo>();
 
   if (!ext->GetString(kPrefPath, &path))
     return scoped_ptr<ExtensionInfo>();
 
   // Make path absolute. Unpacked extensions will already have absolute paths,
   // otherwise make it so.
-  if (location_value != Extension::LOAD) {
-    DCHECK(location_value == Extension::COMPONENT ||
+  if (location_value != Manifest::LOAD) {
+    DCHECK(location_value == Manifest::COMPONENT ||
            !FilePath(path).IsAbsolute());
     path = install_directory_.Append(path).value();
   }
 
   // Only the following extension types can be installed permanently in the
   // preferences.
-  Extension::Location location =
-      static_cast<Extension::Location>(location_value);
-  if (location != Extension::INTERNAL &&
-      location != Extension::LOAD &&
-      !Extension::IsExternalLocation(location)) {
+  Manifest::Location location =
+      static_cast<Manifest::Location>(location_value);
+  if (location != Manifest::INTERNAL &&
+      location != Manifest::LOAD &&
+      !Manifest::IsExternalLocation(location)) {
     NOTREACHED();
     return scoped_ptr<ExtensionInfo>();
   }
 
   const DictionaryValue* manifest = NULL;
-  if (location != Extension::LOAD &&
+  if (location != Manifest::LOAD &&
       !ext->GetDictionary(kPrefManifest, &manifest)) {
     LOG(WARNING) << "Missing manifest for extension " << extension_id;
     // Just a warning for now.
   }
 
   return scoped_ptr<ExtensionInfo>(
       new ExtensionInfo(manifest, extension_id, FilePath(path), location));
 }
 
 scoped_ptr<ExtensionPrefs::ExtensionsInfo>
@@ skipping 93 matching lines @@
   FilePath::StringType path;
   int location_value;
   if (!ext->GetInteger(kPrefLocation, &location_value))
     return scoped_ptr<ExtensionInfo>();
 
   if (!ext->GetString(kPrefPath, &path))
     return scoped_ptr<ExtensionInfo>();
 
   // Make path absolute. Unpacked extensions will already have absolute paths,
   // otherwise make it so.
-  if (location_value != Extension::LOAD) {
-    DCHECK(location_value == Extension::COMPONENT ||
+  if (location_value != Manifest::LOAD) {
+    DCHECK(location_value == Manifest::COMPONENT ||
            !FilePath(path).IsAbsolute());
     path = install_directory_.Append(path).value();
   }
 
   // Only the following extension types can be installed permanently in the
   // preferences.
-  Extension::Location location =
-      static_cast<Extension::Location>(location_value);
-  if (location != Extension::INTERNAL &&
-      location != Extension::LOAD &&
-      !Extension::IsExternalLocation(location)) {
+  Manifest::Location location =
+      static_cast<Manifest::Location>(location_value);
+  if (location != Manifest::INTERNAL &&
+      location != Manifest::LOAD &&
+      !Manifest::IsExternalLocation(location)) {
     NOTREACHED();
     return scoped_ptr<ExtensionInfo>();
   }
 
   const DictionaryValue* manifest = NULL;
-  if (location != Extension::LOAD &&
+  if (location != Manifest::LOAD &&
       !ext->GetDictionary(kPrefManifest, &manifest)) {
     LOG(WARNING) << "Missing manifest for extension " << extension_id;
     // Just a warning for now.
   }
 
   return scoped_ptr<ExtensionInfo>(
       new ExtensionInfo(manifest, extension_id, FilePath(path), location));
 }
 
 scoped_ptr<ExtensionPrefs::ExtensionsInfo> ExtensionPrefs::
@@ skipping 534 matching lines @@
       Value::CreateBooleanValue(extension->was_installed_by_default()));
   extension_dict->Set(kPrefInstallTime,
                       Value::CreateStringValue(
                           base::Int64ToString(install_time.ToInternalValue())));
 
   FilePath::StringType path = MakePathRelative(install_directory_,
       extension->path());
   extension_dict->Set(kPrefPath, Value::CreateStringValue(path));
   // We store prefs about LOAD extensions, but don't cache their manifest
   // since it may change on disk.
-  if (extension->location() != Extension::LOAD) {
+  if (extension->location() != Manifest::LOAD) {
     extension_dict->Set(kPrefManifest,
                         extension->manifest()->value()->DeepCopy());
   }
 }
 
 void ExtensionPrefs::FinishExtensionInfoPrefs(
     const std::string& extension_id,
     const base::Time install_time,
     bool needs_sort_ordinal,
     const syncer::StringOrdinal& suggested_page_ordinal,
@@ skipping 28 matching lines @@
     is_enabled = initial_state == Extension::ENABLED;
   }
 
   extension_pref_value_map_->RegisterExtension(extension_id, install_time,
                                                is_enabled);
   content_settings_store_->RegisterExtension(extension_id, install_time,
                                              is_enabled);
 }
 
 }  // namespace extensions