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

chrome/browser/extensions/installed_loader.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/installed_loader.h"
 
 #include "base/file_path.h"
 #include "base/metrics/histogram.h"
 #include "base/stringprintf.h"
 #include "base/threading/thread_restrictions.h"
@@ skipping 14 matching lines @@
 #include "chrome/common/extensions/extension_manifest_constants.h"
 #include "chrome/common/extensions/manifest.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/user_metrics.h"
 
 using content::BrowserThread;
 using content::UserMetricsAction;
 using extensions::Extension;
 using extensions::ExtensionInfo;
+using extensions::Manifest;
 
 namespace errors = extension_manifest_errors;
 
 namespace {
 
 // The following enumeration is used in histograms matching
 // Extensions.ManifestReload* .  Values may be added, as long as existing
 // values are not changed.
 enum ManifestReloadReason {
   NOT_NEEDED = 0,  // Reload not needed.
   UNPACKED_DIR,  // Unpacked directory.
   NEEDS_RELOCALIZATION,  // The locale has changed since we read this extension.
   NUM_MANIFEST_RELOAD_REASONS
 };
 
 ManifestReloadReason ShouldReloadExtensionManifest(const ExtensionInfo& info) {
   // Always reload manifests of unpacked extensions, because they can change
   // on disk independent of the manifest in our prefs.
-  if (info.extension_location == Extension::LOAD)
+  if (info.extension_location == Manifest::LOAD)
     return UNPACKED_DIR;
 
   // Reload the manifest if it needs to be relocalized.
   if (extension_l10n_util::ShouldRelocalizeManifest(info))
     return NEEDS_RELOCALIZATION;
 
   return NOT_NEEDED;
 }
 
 void DispatchOnInstalledEvent(
@@ skipping 34 matching lines @@
         GetCreationFlags(&info),
         &error);
   } else {
     error = errors::kManifestUnreadable;
   }
 
   // Once installed, non-unpacked extensions cannot change their IDs (e.g., by
   // updating the 'key' field in their manifest).
   // TODO(jstritar): migrate preferences when unpacked extensions change IDs.
   if (extension &&
-      extension->location() != Extension::LOAD &&
+      extension->location() != Manifest::LOAD &&
       info.extension_id != extension->id()) {
     error = errors::kCannotChangeExtensionID;
     extension = NULL;
     content::RecordAction(UserMetricsAction("Extensions.IDChangedError"));
   }
 
   // Check policy on every load in case an extension was blacklisted while
   // Chrome was not running.
   const ManagementPolicy* policy = extensions::ExtensionSystem::Get(
       extension_service_->profile())->management_policy();
@@ skipping 127 matching lines @@
   int extension_user_count = 0;
   int extension_external_count = 0;
   int theme_count = 0;
   int page_action_count = 0;
   int browser_action_count = 0;
   int disabled_for_permissions_count = 0;
   int item_user_count = 0;
   const ExtensionSet* extensions = extension_service_->extensions();
   ExtensionSet::const_iterator ex;
   for (ex = extensions->begin(); ex != extensions->end(); ++ex) {
-    Extension::Location location = (*ex)->location();
-    Extension::Type type = (*ex)->GetType();
+    Manifest::Location location = (*ex)->location();
+    Manifest::Type type = (*ex)->GetType();
     if ((*ex)->is_app()) {
       UMA_HISTOGRAM_ENUMERATION("Extensions.AppLocation",
                                 location, 100);
-    } else if (type == Extension::TYPE_EXTENSION) {
+    } else if (type == Manifest::TYPE_EXTENSION) {
       UMA_HISTOGRAM_ENUMERATION("Extensions.ExtensionLocation",
                                 location, 100);
     }
 
     // Don't count component extensions, since they are only extensions as an
     // implementation detail.
-    if (location == Extension::COMPONENT)
+    if (location == Manifest::COMPONENT)
       continue;
 
     // Don't count unpacked extensions, since they're a developer-specific
     // feature.
-    if (location == Extension::LOAD)
+    if (location == Manifest::LOAD)
       continue;
 
     // Using an enumeration shows us the total installed ratio across all users.
     // Using the totals per user at each startup tells us the distribution of
     // usage for each user (e.g. 40% of users have at least one app installed).
     UMA_HISTOGRAM_ENUMERATION("Extensions.LoadType", type, 100);
     switch (type) {
-      case Extension::TYPE_THEME:
+      case Manifest::TYPE_THEME:
         ++theme_count;
         break;
-      case Extension::TYPE_USER_SCRIPT:
+      case Manifest::TYPE_USER_SCRIPT:
         ++user_script_count;
         break;
-      case Extension::TYPE_HOSTED_APP:
+      case Manifest::TYPE_HOSTED_APP:
         ++hosted_app_count;
-        if (Extension::IsExternalLocation(location)) {
+        if (Manifest::IsExternalLocation(location)) {
           ++app_external_count;
         } else {
           ++app_user_count;
         }
         break;
-      case Extension::TYPE_LEGACY_PACKAGED_APP:
+      case Manifest::TYPE_LEGACY_PACKAGED_APP:
         ++legacy_packaged_app_count;
-        if (Extension::IsExternalLocation(location)) {
+        if (Manifest::IsExternalLocation(location)) {
           ++app_external_count;
         } else {
           ++app_user_count;
         }
         break;
-      case Extension::TYPE_PLATFORM_APP:
+      case Manifest::TYPE_PLATFORM_APP:
         ++platform_app_count;
-        if (Extension::IsExternalLocation(location)) {
+        if (Manifest::IsExternalLocation(location)) {
           ++app_external_count;
         } else {
           ++app_user_count;
         }
         break;
-      case Extension::TYPE_EXTENSION:
+      case Manifest::TYPE_EXTENSION:
       default:
-        if (Extension::IsExternalLocation(location)) {
+        if (Manifest::IsExternalLocation(location)) {
           ++extension_external_count;
         } else {
           ++extension_user_count;
         }
         break;
     }
-    if (!Extension::IsExternalLocation((*ex)->location()))
+    if (!Manifest::IsExternalLocation((*ex)->location()))
       ++item_user_count;
     ExtensionActionManager* extension_action_manager =
         ExtensionActionManager::Get(extension_service_->profile());
     if (extension_action_manager->GetPageAction(**ex))
       ++page_action_count;
     if (extension_action_manager->GetBrowserAction(**ex))
       ++browser_action_count;
 
     if ((*ex)->is_content_pack())
       ++content_pack_count;
@@ skipping 31 matching lines @@
   UMA_HISTOGRAM_COUNTS_100("Extensions.LoadPageAction", page_action_count);
   UMA_HISTOGRAM_COUNTS_100("Extensions.LoadBrowserAction",
                            browser_action_count);
   UMA_HISTOGRAM_COUNTS_100("Extensions.LoadContentPack", content_pack_count);
   UMA_HISTOGRAM_COUNTS_100("Extensions.DisabledForPermissions",
                            disabled_for_permissions_count);
 }
 
 int InstalledLoader::GetCreationFlags(const ExtensionInfo* info) {
   int flags = extension_prefs_->GetCreationFlags(info->extension_id);
-  if (info->extension_location != Extension::LOAD)
+  if (info->extension_location != Manifest::LOAD)
     flags |= Extension::REQUIRE_KEY;
   if (extension_prefs_->AllowFileAccess(info->extension_id))
     flags |= Extension::ALLOW_FILE_ACCESS;
   return flags;
 }
 
 }  // namespace extensions