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

chrome/browser/extensions/unpacked_installer.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/unpacked_installer.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/string_util.h"
 #include "base/threading/thread_restrictions.h"
 #include "chrome/browser/extensions/extension_install_prompt.h"
 #include "chrome/browser/extensions/extension_install_ui.h"
 #include "chrome/browser/extensions/extension_prefs.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/permissions_updater.h"
 #include "chrome/browser/extensions/requirements_checker.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_file_util.h"
+#include "chrome/common/extensions/manifest.h"
 #include "content/public/browser/browser_thread.h"
 #include "sync/api/string_ordinal.h"
 
 using content::BrowserThread;
 using extensions::Extension;
 
 namespace {
 
 const char kUnpackedExtensionsBlacklistedError[] =
     "Loading of unpacked extensions is disabled by the administrator.";
@@ skipping 98 matching lines @@
   file_util::AbsolutePath(&extension_path_);
 
   if (!IsLoadingUnpackedAllowed()) {
     ReportExtensionLoadError(kUnpackedExtensionsBlacklistedError);
     return;
   }
 
   std::string error;
   extension_ = extension_file_util::LoadExtension(
       extension_path_,
-      Extension::LOAD,
+      Manifest::LOAD,
       GetFlags(),
       &error);
 
   if (!extension_.get()) {
     ReportExtensionLoadError(error);
     return;
   }
 
   CheckRequirements();
 }
@@ skipping 13 matching lines @@
     ReportExtensionLoadError(JoinString(requirement_errors, ' '));
     return;
   }
 
   OnLoaded();
 }
 
 int UnpackedInstaller::GetFlags() {
   std::string id = Extension::GenerateIdForPath(extension_path_);
   bool allow_file_access =
-      Extension::ShouldAlwaysAllowFileAccess(Extension::LOAD);
+      Manifest::ShouldAlwaysAllowFileAccess(Manifest::LOAD);
   if (service_weak_->extension_prefs()->HasAllowFileAccessSetting(id))
     allow_file_access = service_weak_->extension_prefs()->AllowFileAccess(id);
 
   int result = Extension::FOLLOW_SYMLINKS_ANYWHERE;
   if (allow_file_access)
     result |= Extension::ALLOW_FILE_ACCESS;
   if (require_modern_manifest_version_)
     result |= Extension::REQUIRE_MODERN_MANIFEST_VERSION;
 
   return result;
@@ skipping 30 matching lines @@
       base::Bind(
           &UnpackedInstaller::LoadWithFileAccess, this, GetFlags()));
 }
 
 void UnpackedInstaller::LoadWithFileAccess(int flags) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   std::string error;
   extension_ = extension_file_util::LoadExtension(
       extension_path_,
-      Extension::LOAD,
+      Manifest::LOAD,
       flags,
       &error);
 
   if (!extension_.get()) {
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
         base::Bind(
             &UnpackedInstaller::ReportExtensionLoadError,
             this, error));
     return;
   }
@@ skipping 29 matching lines @@
 
   PermissionsUpdater perms_updater(service_weak_->profile());
   perms_updater.GrantActivePermissions(extension_, false);
   service_weak_->OnExtensionInstalled(extension_,
                                       syncer::StringOrdinal(),
                                       false /* no requirement errors */,
                                       false /* don't wait for idle */);
 }
 
 }  // namespace extensions