Move Extension into extensions namespace

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_util.h"
@@ skipping 11 matching lines @@
 #include "chrome/common/extensions/extension_l10n_util.h"
 #include "chrome/common/extensions/extension_manifest_constants.h"
 #include "chrome/common/extensions/extension_message_bundle.h"
 #include "chrome/common/extensions/extension_messages.h"
 #include "chrome/common/extensions/extension_resource.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;
+
 namespace errors = extension_manifest_errors;
 
 namespace extension_file_util {
 
 // Validates locale info. Doesn't check if messages.json files are valid.
-static bool ValidateLocaleInfo(const Extension& extension, std::string* error);
+static bool ValidateLocaleInfo(const Extension& extension,
+                               std::string* error);
 
 // Returns false and sets the error if script file can't be loaded,
 // or if it's not UTF-8 encoded.
 static bool IsScriptValid(const FilePath& path, const FilePath& relative_path,
                           int message_id, std::string* error);
 
 const char kInstallDirectoryName[] = "Extensions";
 
 FilePath InstallExtension(const FilePath& unpacked_source_dir,
                           const std::string& id,
@@ skipping 69 matching lines @@
   // 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,
                                        int flags,
                                        std::string* error) {
-  return LoadExtension(
-      extension_path, std::string(), location, flags, 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,
                                        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));
+  scoped_refptr<Extension> extension(Extension::Create(extension_path,
+                                                       location,
+                                                       *manifest,
+                                                       flags,
+                                                       extension_id,
+                                                       error));
   if (!extension.get())
     return NULL;
 
   if (!ValidateExtension(extension.get(), error))
     return NULL;
 
   return extension;
 }
 
 DictionaryValue* LoadManifest(const FilePath& extension_path,
@@ skipping 23 matching lines @@
   }
 
   if (!root->IsType(Value::TYPE_DICTIONARY)) {
     *error = l10n_util::GetStringUTF8(IDS_EXTENSION_MANIFEST_INVALID);
     return NULL;
   }
 
   return static_cast<DictionaryValue*>(root.release());
 }
 
-bool ValidateExtension(const Extension* extension, std::string* error) {
+bool ValidateExtension(const Extension* extension,
+                       std::string* error) {
   // 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 (!file_util::PathExists(path)) {
       *error =
           l10n_util::GetStringFUTF8(IDS_EXTENSION_LOAD_ICON_FAILED,
                                     UTF8ToUTF16(iter->second));
@@ skipping 224 matching lines @@
     }
   }
 }
 
 ExtensionMessageBundle* LoadExtensionMessageBundle(
     const FilePath& extension_path,
     const std::string& default_locale,
     std::string* error) {
   error->clear();
   // Load locale information if available.
-  FilePath locale_path = extension_path.Append(Extension::kLocaleFolder);
+  FilePath locale_path = extension_path.Append(
+      Extension::kLocaleFolder);
   if (!file_util::PathExists(locale_path))
     return NULL;
 
   std::set<std::string> locales;
   if (!extension_l10n_util::GetValidLocales(locale_path, &locales, error))
     return NULL;
 
   if (default_locale.empty() ||
       locales.find(default_locale) == locales.end()) {
     *error = l10n_util::GetStringUTF8(
@@ skipping 28 matching lines @@
   }
 
   // Add @@extension_id reserved message here, so it's available to
   // non-localized extensions too.
   returnValue->insert(
       std::make_pair(ExtensionMessageBundle::kExtensionIdKey, extension_id));
 
   return returnValue;
 }
 
-static bool ValidateLocaleInfo(const Extension& extension, std::string* error) {
+static bool ValidateLocaleInfo(const Extension& extension,
+                               std::string* error) {
   // default_locale and _locales have to be both present or both missing.
-  const FilePath path = extension.path().Append(Extension::kLocaleFolder);
+  const FilePath path = extension.path().Append(
+      Extension::kLocaleFolder);
   bool path_exists = file_util::PathExists(path);
   std::string default_locale = extension.default_locale();
 
   // If both default locale and _locales folder are empty, skip verification.
   if (default_locale.empty() && !path_exists)
     return true;
 
   if (default_locale.empty() && path_exists) {
     *error = l10n_util::GetStringUTF8(
         IDS_EXTENSION_LOCALES_NO_DEFAULT_LOCALE_SPECIFIED);
@@ skipping 216 matching lines @@
     return temp_path;
 
   return FilePath();
 }
 
 void DeleteFile(const FilePath& path, bool recursive) {
   file_util::Delete(path, recursive);
 }
 
 }  // namespace extension_file_util