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

chrome/browser/extensions/extension_service.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_service.h"
 
 #include <algorithm>
 #include <iterator>
 #include <set>
 
@@ skipping 68 matching lines @@
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_file_util.h"
 #include "chrome/common/extensions/extension_manifest_constants.h"
 #include "chrome/common/extensions/extension_messages.h"
 #include "chrome/common/extensions/extension_resource.h"
 #include "chrome/common/extensions/feature_switch.h"
 #include "chrome/common/extensions/features/feature.h"
-#include "chrome/common/extensions/manifest.h"
 #include "chrome/common/extensions/manifest_url_handler.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/startup_metric_utils.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/devtools_manager.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/plugin_service.h"
@@ skipping 19 matching lines @@
 
 using content::BrowserContext;
 using content::BrowserThread;
 using content::DevToolsAgentHost;
 using content::PluginService;
 using extensions::CrxInstaller;
 using extensions::Extension;
 using extensions::ExtensionIdSet;
 using extensions::ExtensionInfo;
 using extensions::FeatureSwitch;
+using extensions::Manifest;
 using extensions::PermissionMessage;
 using extensions::PermissionMessages;
 using extensions::PermissionSet;
 using extensions::UnloadedExtensionInfo;
 
 namespace errors = extension_manifest_errors;
 
 namespace {
 
 // Histogram values for logging events related to externally installed
@@ skipping 98 matching lines @@
 void ExtensionService::AddProviderForTesting(
     extensions::ExternalProviderInterface* test_provider) {
   CHECK(test_provider);
   external_extension_providers_.push_back(
       linked_ptr<extensions::ExternalProviderInterface>(test_provider));
 }
 
 bool ExtensionService::OnExternalExtensionUpdateUrlFound(
     const std::string& id,
     const GURL& update_url,
-    Extension::Location location) {
+    Manifest::Location location) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   CHECK(Extension::IdIsValid(id));
 
   const Extension* extension = GetExtensionById(id, true);
   if (extension) {
     // Already installed. Skip this install if the current location has
     // higher priority than |location|.
-    Extension::Location current = extension->location();
-    if (current == Extension::GetHigherPriorityLocation(current, location))
+    Manifest::Location current = extension->location();
+    if (current == Manifest::GetHigherPriorityLocation(current, location))
       return false;
     // Otherwise, overwrite the current installation.
   }
 
   // Add |id| to the set of pending extensions.  If it can not be added,
   // then there is already a pending record from a higher-priority install
   // source.  In this case, signal that this extension will not be
   // installed by returning false.
   if (!pending_extension_manager()->AddFromExternalUpdateUrl(
           id, update_url, location)) {
@@ skipping 546 matching lines @@
       extension, "Extensions.Permissions_Uninstall");
 
   // Unload before doing more cleanup to ensure that nothing is hanging on to
   // any of these resources.
   UnloadExtension(extension_id, extension_misc::UNLOAD_REASON_UNINSTALL);
 
   extension_prefs_->OnExtensionUninstalled(extension_id, extension->location(),
                                            external_uninstall);
 
   // Tell the backend to start deleting installed extensions on the file thread.
-  if (Extension::LOAD != extension->location()) {
+  if (Manifest::LOAD != extension->location()) {
     if (!GetFileTaskRunner()->PostTask(
             FROM_HERE,
             base::Bind(
                 &extension_file_util::UninstallExtension,
                 install_directory_,
                 extension_id)))
       NOTREACHED();
   }
 
   GURL launch_web_url_origin(extension->launch_web_url());
@@ skipping 739 matching lines @@
   return true;
 }
 
 bool ExtensionService::IsIncognitoEnabled(
     const std::string& extension_id) const {
   const Extension* extension = GetInstalledExtension(extension_id);
   if (extension && !extension->can_be_incognito_enabled())
     return false;
   // If this is an existing component extension we always allow it to
   // work in incognito mode.
-  if (extension && extension->location() == Extension::COMPONENT)
+  if (extension && extension->location() == Manifest::COMPONENT)
     return true;
 
   // Check the prefs.
   return extension_prefs_->IsIncognitoEnabled(extension_id);
 }
 
 void ExtensionService::SetIsIncognitoEnabled(
     const std::string& extension_id, bool enabled) {
   const Extension* extension = GetInstalledExtension(extension_id);
   if (extension && !extension->can_be_incognito_enabled())
     return;
-  if (extension && extension->location() == Extension::COMPONENT) {
+  if (extension && extension->location() == Manifest::COMPONENT) {
     // This shouldn't be called for component extensions unless they are
     // syncable.
     DCHECK(extension->IsSyncable());
 
     // If we are here, make sure the we aren't trying to change the value.
     DCHECK_EQ(enabled, IsIncognitoEnabled(extension_id));
 
     return;
   }
 
@@ skipping 168 matching lines @@
   if (update_once_all_providers_are_ready_ && updater()) {
     update_once_all_providers_are_ready_ = false;
     updater()->CheckNow(extensions::ExtensionUpdater::CheckParams());
   }
 
   // Uninstall all the unclaimed extensions.
   scoped_ptr<extensions::ExtensionPrefs::ExtensionsInfo> extensions_info(
       extension_prefs_->GetInstalledExtensionsInfo());
   for (size_t i = 0; i < extensions_info->size(); ++i) {
     ExtensionInfo* info = extensions_info->at(i).get();
-    if (Extension::IsExternalLocation(info->extension_location))
+    if (Manifest::IsExternalLocation(info->extension_location))
       CheckExternalUninstall(info->extension_id);
   }
   IdentifyAlertableExtensions();
 }
 
 void ExtensionService::IdentifyAlertableExtensions() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Build up the lists of extensions that require acknowledgment. If this is
   // the first time, grandfather extensions that would have caused
@@ skipping 66 matching lines @@
 void ExtensionService::AcknowledgeExternalExtension(const std::string& id) {
   extension_prefs_->AcknowledgeExternalExtension(id);
   UpdateExternalExtensionAlert();
 }
 
 bool ExtensionService::IsUnacknowledgedExternalExtension(
     const Extension* extension) {
   if (!FeatureSwitch::prompt_for_external_extensions()->IsEnabled())
     return false;
 
-  return (Extension::IsExternalLocation(extension->location()) &&
+  return (Manifest::IsExternalLocation(extension->location()) &&
           !extension_prefs_->IsExternalExtensionAcknowledged(extension->id()) &&
           !(extension_prefs_->GetDisableReasons(extension->id()) &
                 Extension::DISABLE_SIDELOAD_WIPEOUT));
 }
 
 void ExtensionService::HandleExtensionAlertDetails() {
   extension_error_ui_->ShowExtensions();
 }
 
 void ExtensionService::UpdateExternalExtensionAlert() {
@@ skipping 162 matching lines @@
       content::Source<Profile>(profile_),
       content::NotificationService::NoDetails());
 }
 
 void ExtensionService::AddExtension(const Extension* extension) {
   // TODO(jstritar): We may be able to get rid of this branch by overriding the
   // default extension state to DISABLED when the --disable-extensions flag
   // is set (http://crbug.com/29067).
   if (!extensions_enabled() &&
       !extension->is_theme() &&
-      extension->location() != Extension::COMPONENT &&
-      !Extension::IsExternalLocation(extension->location())) {
+      extension->location() != Manifest::COMPONENT &&
+      !Manifest::IsExternalLocation(extension->location())) {
     return;
   }
 
   SetBeingUpgraded(extension, false);
 
   // The extension is now loaded, remove its data from unloaded extension map.
   unloaded_extension_paths_.erase(extension->id());
 
   // If a terminated extension is loaded, remove it from the terminated list.
   UntrackTerminatedExtension(extension->id());
@@ skipping 157 matching lines @@
   }
 
   // Silently grant all active permissions to default apps only on install.
   // After install they should behave like other apps.
   if (is_default_app_install)
     GrantPermissions(extension, true);
 
   if (is_extension_upgrade) {
     // Other than for unpacked extensions, CrxInstaller should have guaranteed
     // that we aren't downgrading.
-    if (extension->location() != Extension::LOAD)
+    if (extension->location() != Manifest::LOAD)
       CHECK_GE(extension->version()->CompareTo(*(old->version())), 0);
 
     // Extensions get upgraded if the privileges are allowed to increase or
     // the privileges haven't increased.
     if (!is_privilege_increase) {
       SetBeingUpgraded(old, true);
       SetBeingUpgraded(extension, true);
     }
 
     // If the extension was already disabled, suppress any alerts for becoming
@@ skipping 37 matching lines @@
         extension->id(),
         static_cast<Extension::DisableReason>(disable_reasons));
   }
 }
 
 void ExtensionService::MaybeWipeout(
     const extensions::Extension* extension) {
   if (!wipeout_is_active_)
     return;
 
-  if (extension->GetType() != Extension::TYPE_EXTENSION)
+  if (extension->GetType() != Manifest::TYPE_EXTENSION)
     return;
 
-  Extension::Location location = extension->location();
-  if (location != Extension::EXTERNAL_REGISTRY)
+  Manifest::Location location = extension->location();
+  if (location != Manifest::EXTERNAL_REGISTRY)
     return;
 
   if (extension_prefs_->IsExternalExtensionExcludedFromWipeout(extension->id()))
     return;
 
   int disable_reasons = extension_prefs_->GetDisableReasons(extension->id());
   if (disable_reasons == Extension::DISABLE_NONE) {
     extension_prefs_->SetExtensionState(extension->id(), Extension::DISABLED);
     extension_prefs_->AddDisableReason(
         extension->id(),
         static_cast<Extension::DisableReason>(
         Extension::DISABLE_SIDELOAD_WIPEOUT));
     UMA_HISTOGRAM_BOOLEAN("DisabledExtension.ExtensionWipedStatus", true);
     wipeout_count_++;
   }
 }
 
 void ExtensionService::UpdateActiveExtensionsInCrashReporter() {
   std::set<std::string> extension_ids;
   for (ExtensionSet::const_iterator iter = extensions_.begin();
        iter != extensions_.end(); ++iter) {
     const Extension* extension = *iter;
-    if (!extension->is_theme() && extension->location() != Extension::COMPONENT)
+    if (!extension->is_theme() && extension->location() != Manifest::COMPONENT)
       extension_ids.insert(extension->id());
   }
 
   child_process_logging::SetActiveExtensions(extension_ids);
 }
 
 void ExtensionService::OnExtensionInstalled(
     const Extension* extension,
     const syncer::StringOrdinal& page_ordinal,
     bool has_requirement_errors,
@@ skipping 50 matching lines @@
   } else if (extension_prefs_->GetDisableReasons(id) ==
       Extension::DISABLE_UNSUPPORTED_REQUIREMENT) {
     initial_enable = true;
     extension_prefs_->ClearDisableReasons(id);
   }
 
   if (!GetInstalledExtension(extension->id())) {
     UMA_HISTOGRAM_ENUMERATION("Extensions.InstallType",
                               extension->GetType(), 100);
     UMA_HISTOGRAM_ENUMERATION("Extensions.InstallSource",
-                              extension->location(), Extension::NUM_LOCATIONS);
+                              extension->location(), Manifest::NUM_LOCATIONS);
     RecordPermissionMessagesHistogram(
         extension, "Extensions.Permissions_Install");
   } else {
     UMA_HISTOGRAM_ENUMERATION("Extensions.UpdateType",
                               extension->GetType(), 100);
     UMA_HISTOGRAM_ENUMERATION("Extensions.UpdateSource",
-                              extension->location(), Extension::NUM_LOCATIONS);
+                              extension->location(), Manifest::NUM_LOCATIONS);
   }
 
   // Certain extension locations are specific enough that we can
   // auto-acknowledge any extension that came from one of them.
-  if (extension->location() == Extension::EXTERNAL_POLICY_DOWNLOAD)
+  if (extension->location() == Manifest::EXTERNAL_POLICY_DOWNLOAD)
     AcknowledgeExternalExtension(extension->id());
   const Extension::State initial_state =
       initial_enable ? Extension::ENABLED : Extension::DISABLED;
   if (ShouldDelayExtensionUpdate(id, wait_for_idle)) {
     extension_prefs_->SetDelayedInstallInfo(extension, initial_state,
                                             page_ordinal);
 
     // Transfer ownership of |extension|.
     delayed_updates_for_idle_.Insert(extension);
 
@@ skipping 54 matching lines @@
 void ExtensionService::FinishInstallation(const Extension* extension) {
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_EXTENSION_INSTALLED,
       content::Source<Profile>(profile_),
       content::Details<const Extension>(extension));
 
   bool unacknowledged_external = IsUnacknowledgedExternalExtension(extension);
 
   // Unpacked extensions default to allowing file access, but if that has been
   // overridden, don't reset the value.
-  if (Extension::ShouldAlwaysAllowFileAccess(extension->location()) &&
+  if (Manifest::ShouldAlwaysAllowFileAccess(extension->location()) &&
       !extension_prefs_->HasAllowFileAccessSetting(extension->id())) {
     extension_prefs_->SetAllowFileAccess(extension->id(), true);
   }
 
   AddExtension(extension);
 
 #if defined(ENABLE_THEMES)
   // We do this here since AddExtension() is always called on browser
   // startup, and we only really care about the last theme installed.
   // If that ever changes and we have to move this code somewhere
@@ skipping 47 matching lines @@
                      INCLUDE_TERMINATED |
                      INCLUDE_BLACKLISTED;
   return GetExtensionById(id, include_mask);
 }
 
 bool ExtensionService::ExtensionBindingsAllowed(const GURL& url) {
   // Allow bindings for all packaged extensions and component hosted apps.
   const Extension* extension = extensions_.GetExtensionOrAppByURL(
       ExtensionURLInfo(url));
   return extension && (!extension->is_hosted_app() ||
-                       extension->location() == Extension::COMPONENT);
+                       extension->location() == Manifest::COMPONENT);
 }
 
 bool ExtensionService::ShouldBlockUrlInBrowserTab(GURL* url) {
   const Extension* extension = extensions_.GetExtensionOrAppByURL(
       ExtensionURLInfo(*url));
   if (extension && extension->is_platform_app()) {
     *url = GURL(chrome::kExtensionInvalidRequestURL);
     return true;
   }
 
   return false;
 }
 
 bool ExtensionService::OnExternalExtensionFileFound(
          const std::string& id,
          const Version* version,
          const FilePath& path,
-         Extension::Location location,
+         Manifest::Location location,
          int creation_flags,
          bool mark_acknowledged) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   CHECK(Extension::IdIsValid(id));
   if (extension_prefs_->IsExternalExtensionUninstalled(id))
     return false;
 
   // Before even bothering to unpack, check and see if we already have this
   // version. This is important because these extensions are going to get
   // installed on every startup.
   const Extension* existing = GetExtensionById(id, true);
 
   if (existing) {
     // The default apps will have the location set as INTERNAL. Since older
     // default apps are installed as EXTERNAL, we override them. However, if the
     // app is already installed as internal, then do the version check.
     // TODO(grv) : Remove after Q1-2013.
     bool is_default_apps_migration =
-        (location == Extension::INTERNAL &&
-         Extension::IsExternalLocation(existing->location()));
+        (location == Manifest::INTERNAL &&
+         Manifest::IsExternalLocation(existing->location()));
 
     if (!is_default_apps_migration) {
       DCHECK(version);
 
       switch (existing->version()->CompareTo(*version)) {
         case -1:  // existing version is older, we should upgrade
           break;
         case 0:  // existing version is same, do nothing
           return false;
         case 1:  // existing version is newer, uh-oh
@@ skipping 175 matching lines @@
 }
 
 bool ExtensionService::HasApps() const {
   return !GetAppIds().empty();
 }
 
 ExtensionIdSet ExtensionService::GetAppIds() const {
   ExtensionIdSet result;
   for (ExtensionSet::const_iterator it = extensions_.begin();
        it != extensions_.end(); ++it) {
-    if ((*it)->is_app() && (*it)->location() != Extension::COMPONENT)
+    if ((*it)->is_app() && (*it)->location() != Manifest::COMPONENT)
       result.insert((*it)->id());
   }
 
   return result;
 }
 
 bool ExtensionService::IsBackgroundPageReady(const Extension* extension) const {
   if (!extension->has_persistent_background_page())
     return true;
   ExtensionRuntimeDataMap::const_iterator it =
@@ skipping 193 matching lines @@
   if (system_->management_policy()->MustRemainEnabled(extension, NULL))
     return true;
 
   if (extension_prefs_->IsExtensionDisabled(extension->id()))
     return false;
 
   if (FeatureSwitch::prompt_for_external_extensions()->IsEnabled()) {
     // External extensions are initially disabled. We prompt the user before
     // enabling them. Hosted apps are excepted because they are not dangerous
     // (they need to be launched by the user anyway).
-    if (extension->GetType() != Extension::TYPE_HOSTED_APP &&
-        Extension::IsExternalLocation(extension->location()) &&
+    if (extension->GetType() != Manifest::TYPE_HOSTED_APP &&
+        Manifest::IsExternalLocation(extension->location()) &&
         !extension_prefs_->IsExternalExtensionAcknowledged(extension->id())) {
       return false;
     }
   }
 
   return true;
 }
 
 bool ExtensionService::IsExtensionIdle(const std::string& extension_id) const {
   ExtensionProcessManager* process_manager = system_->process_manager();
@@ skipping 111 matching lines @@
     scoped_refptr<const Extension> extension = GetInstalledExtension(*it);
     DCHECK(extension);
     if (!extension)
       continue;
     blacklisted_extensions_.Insert(extension);
     UnloadExtension(*it, extension_misc::UNLOAD_REASON_BLACKLIST);
   }
 
   IdentifyAlertableExtensions();
 }