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

chrome/common/extensions/extension_file_util.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/common/extensions/extension_file_util.h"
 
 #include <map>
 #include <vector>
 
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "base/stringprintf.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/extensions/api/extension_action/action_info.h"
 #include "chrome/common/extensions/api/extension_action/browser_action_handler.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_l10n_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/manifest.h"
 #include "chrome/common/extensions/manifest_url_handler.h"
 #include "chrome/common/extensions/message_bundle.h"
 #include "grit/generated_resources.h"
 #include "net/base/escape.h"
 #include "net/base/file_stream.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using extensions::Extension;
+using extensions::Manifest;
 
 namespace errors = extension_manifest_errors;
 
 namespace {
 
 const FilePath::CharType kTempDirectoryName[] = FILE_PATH_LITERAL("Temp");
 
 bool ValidateExtensionIconSet(const ExtensionIconSet& icon_set,
                               const Extension* extension,
                               int error_message_id,
@@ skipping 82 matching lines @@
 
 void UninstallExtension(const FilePath& extensions_dir,
                         const std::string& id) {
   // We don't care about the return value. If this fails (and it can, due to
   // plugins that aren't unloaded yet, it will get cleaned up by
   // ExtensionService::GarbageCollectExtensions).
   file_util::Delete(extensions_dir.AppendASCII(id), true);  // recursive.
 }
 
 scoped_refptr<Extension> LoadExtension(const FilePath& extension_path,
-                                       Extension::Location location,
+                                       Manifest::Location location,
                                        int flags,
                                        std::string* error) {
   return LoadExtension(extension_path, std::string(), location, flags, error);
 }
 
 scoped_refptr<Extension> LoadExtension(const FilePath& extension_path,
                                        const std::string& extension_id,
-                                       Extension::Location location,
+                                       Manifest::Location location,
                                        int flags,
                                        std::string* error) {
   scoped_ptr<DictionaryValue> manifest(LoadManifest(extension_path, error));
   if (!manifest.get())
     return NULL;
   if (!extension_l10n_util::LocalizeExtension(extension_path, manifest.get(),
                                               error)) {
     return NULL;
   }
 
   scoped_refptr<Extension> extension(Extension::Create(extension_path,
                                                        location,
                                                        *manifest,
                                                        flags,
                                                        extension_id,
                                                        error));
   if (!extension.get())
     return NULL;
 
-  Extension::InstallWarningVector warnings;
+  extensions::InstallWarning::Vector warnings;
   if (!ValidateExtension(extension.get(), error, &warnings))
     return NULL;
   extension->AddInstallWarnings(warnings);
 
   return extension;
 }
 
 DictionaryValue* LoadManifest(const FilePath& extension_path,
                               std::string* error) {
   FilePath manifest_path =
@@ skipping 60 matching lines @@
       !file_util::GetFileSize(path, &size) ||
       size == 0) {
     return false;
   }
 
   return true;
 }
 
 bool ValidateExtension(const Extension* extension,
                        std::string* error,
-                       Extension::InstallWarningVector* warnings) {
+                       extensions::InstallWarning::Vector* warnings) {
   // Validate icons exist.
   for (ExtensionIconSet::IconMap::const_iterator iter =
            extension->icons().map().begin();
        iter != extension->icons().map().end();
        ++iter) {
     const FilePath path = extension->GetResource(iter->second).GetFilePath();
     if (!ValidateFilePath(path)) {
       *error =
           l10n_util::GetStringFUTF8(IDS_EXTENSION_LOAD_ICON_FAILED,
                                     UTF8ToUTF16(iter->second));
@@ skipping 147 matching lines @@
     if (!private_keys.empty()) {
       // Only print one of the private keys because l10n_util doesn't have a way
       // to translate a list of strings.
       *error = l10n_util::GetStringFUTF8(
           IDS_EXTENSION_CONTAINS_PRIVATE_KEY,
           private_keys.front().LossyDisplayName());
       return false;
     }
   } else {
     for (size_t i = 0; i < private_keys.size(); ++i) {
-      warnings->push_back(Extension::InstallWarning(
-          Extension::InstallWarning::FORMAT_TEXT,
+      warnings->push_back(extensions::InstallWarning(
+          extensions::InstallWarning::FORMAT_TEXT,
           l10n_util::GetStringFUTF8(
               IDS_EXTENSION_CONTAINS_PRIVATE_KEY,
               private_keys[i].LossyDisplayName())));
     }
     // Only warn; don't block loading the extension.
   }
   return true;
 }
 
 void GarbageCollectExtensions(
@@ skipping 329 matching lines @@
     return FilePath();
   }
   return temp_path;
 }
 
 void DeleteFile(const FilePath& path, bool recursive) {
   file_util::Delete(path, recursive);
 }
 
 }  // namespace extension_file_util