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

chrome/browser/ui/webui/extensions/extension_settings_handler.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/ui/webui/extensions/extension_settings_handler.h"
 
 #include "base/auto_reset.h"
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 57 matching lines @@
 #include "grit/theme_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 
 using content::RenderViewHost;
 using content::WebContents;
 using extensions::Extension;
 using extensions::ExtensionUpdater;
 using extensions::ExtensionWarning;
 using extensions::ManagementPolicy;
+using extensions::Manifest;
 
 ///////////////////////////////////////////////////////////////////////////////
 //
 // ExtensionSettingsHandler
 //
 ///////////////////////////////////////////////////////////////////////////////
 
 ExtensionSettingsHandler::ExtensionSettingsHandler()
     : extension_service_(NULL),
       management_policy_(NULL),
@@ skipping 36 matching lines @@
   extension->GetBasicInfo(enabled, extension_data);
 
   extension_data->SetBoolean("userModifiable",
       management_policy_->UserMayModifySettings(extension, NULL));
 
   GURL icon =
       ExtensionIconSource::GetIconURL(extension,
                                       extension_misc::EXTENSION_ICON_MEDIUM,
                                       ExtensionIconSet::MATCH_BIGGER,
                                       !enabled, NULL);
-  if (extension->location() == Extension::LOAD)
+  if (extension->location() == Manifest::LOAD)
     extension_data->SetString("path", extension->path().value());
   extension_data->SetString("icon", icon.spec());
   extension_data->SetBoolean("isUnpacked",
-                             extension->location() == Extension::LOAD);
+                             extension->location() == Manifest::LOAD);
   extension_data->SetBoolean("terminated",
       extension_service_->terminated_extensions()->Contains(extension->id()));
   extension_data->SetBoolean("enabledIncognito",
       extension_service_->IsIncognitoEnabled(extension->id()));
   extension_data->SetBoolean("incognitoCanBeEnabled",
                              extension->can_be_incognito_enabled());
   extension_data->SetBoolean("wantsFileAccess", extension->wants_file_access());
   extension_data->SetBoolean("allowFileAccess",
                              extension_service_->AllowFileAccess(extension));
   extension_data->SetBoolean("allow_activity",
       enabled && CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableExtensionActivityUI));
   extension_data->SetBoolean("allow_reload",
-                             extension->location() == Extension::LOAD);
+                             extension->location() == Manifest::LOAD);
   extension_data->SetBoolean("is_hosted_app", extension->is_hosted_app());
   extension_data->SetBoolean("is_platform_app", extension->is_platform_app());
   extension_data->SetBoolean("homepageProvided",
       extensions::ManifestURL::GetHomepageURL(extension).is_valid());
 
   string16 automatically_disabled_text;
   int disable_reasons =
       extension_service_->extension_prefs()->GetDisableReasons(extension->id());
   if ((disable_reasons & Extension::DISABLE_SIDELOAD_WIPEOUT) != 0) {
     automatically_disabled_text = l10n_util::GetStringUTF16(
         IDS_OPTIONS_SIDELOAD_WIPEOUT_AUTOMATIC_DISABLE);
   }
   extension_data->SetString("disableReason", automatically_disabled_text);
 
   string16 location_text;
-  if (extension->location() == Extension::INTERNAL &&
+  if (extension->location() == Manifest::INTERNAL &&
       !extension->UpdatesFromGallery()) {
     location_text = l10n_util::GetStringUTF16(
         IDS_OPTIONS_SIDELOAD_WIPEOUT_DISABLE_REASON_UNKNOWN);
-  } else if (extension->location() == Extension::EXTERNAL_REGISTRY) {
+  } else if (extension->location() == Manifest::EXTERNAL_REGISTRY) {
     location_text = l10n_util::GetStringUTF16(
         IDS_OPTIONS_SIDELOAD_WIPEOUT_DISABLE_REASON_3RD_PARTY);
   }
   extension_data->SetString("locationText", location_text);
 
   // Determine the sort order: Extensions loaded through --load-extensions show
   // up at the top. Disabled extensions show up at the bottom.
-  if (extension->location() == Extension::LOAD)
+  if (extension->location() == Manifest::LOAD)
     extension_data->SetInteger("order", 1);
   else
     extension_data->SetInteger("order", 2);
 
   if (!extension_service_->extension_prefs()->
           GetBrowserActionVisibility(extension)) {
     extension_data->SetBoolean("enable_show_button", true);
   }
 
   // Add views
@@ skipping 30 matching lines @@
       ListValue* warnings_list = new ListValue;
       for (std::vector<std::string>::const_iterator iter = warnings.begin();
            iter != warnings.end(); ++iter) {
         warnings_list->Append(Value::CreateStringValue(*iter));
       }
       extension_data->Set("warnings", warnings_list);
     }
   }
 
   // Add install warnings (these are not the same as warnings!).
-  if (extension->location() == Extension::LOAD) {
-    const Extension::InstallWarningVector& install_warnings =
+  if (extension->location() == Manifest::LOAD) {
+    const std::vector<extensions::InstallWarning>& install_warnings =
         extension->install_warnings();
     if (!install_warnings.empty()) {
       scoped_ptr<ListValue> list(new ListValue());
-      for (Extension::InstallWarningVector::const_iterator it =
+      for (std::vector<extensions::InstallWarning>::const_iterator it =
                install_warnings.begin(); it != install_warnings.end(); ++it) {
         DictionaryValue* item = new DictionaryValue();
         item->SetBoolean("isHTML",
-                         it->format == Extension::InstallWarning::FORMAT_HTML);
+                         it->format == extensions::InstallWarning::FORMAT_HTML);
         item->SetString("message", it->message);
         list->Append(item);
       }
       extension_data->Set("installWarnings", list.release());
     }
   }
 
   return extension_data;
 }
 
@@ skipping 248 matching lines @@
 
 void ExtensionSettingsHandler::ExtensionWarningsChanged() {
   MaybeUpdateAfterNotification();
 }
 
 void ExtensionSettingsHandler::ReloadUnpackedExtensions() {
   const ExtensionSet* extensions = extension_service_->extensions();
   std::vector<const Extension*> unpacked_extensions;
   for (ExtensionSet::const_iterator extension = extensions->begin();
        extension != extensions->end(); ++extension) {
-    if ((*extension)->location() == Extension::LOAD)
+    if ((*extension)->location() == Manifest::LOAD)
       unpacked_extensions.push_back(*extension);
   }
 
   for (std::vector<const Extension*>::iterator iter =
        unpacked_extensions.begin(); iter != unpacked_extensions.end(); ++iter) {
     extension_service_->ReloadExtension((*iter)->id());
   }
 }
 
 void ExtensionSettingsHandler::HandleRequestExtensionsData(
@@ skipping 487 matching lines @@
     std::vector<std::string> requirement_errors) {
   if (requirement_errors.empty()) {
     extension_service_->EnableExtension(extension_id);
   } else {
     ExtensionErrorReporter::GetInstance()->ReportError(
         UTF8ToUTF16(JoinString(requirement_errors, ' ')),
         true /* be noisy */);
   }
   requirements_checker_.reset();
 }