Disallow packing or loading unpacked manifest v1 extensions.

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/threading/thread_restrictions.h"
@@ skipping 71 matching lines @@
 
 // static
 scoped_refptr<UnpackedInstaller> UnpackedInstaller::Create(
     ExtensionService* extension_service) {
   return scoped_refptr<UnpackedInstaller>(
       new UnpackedInstaller(extension_service));
 }
 
 UnpackedInstaller::UnpackedInstaller(ExtensionService* extension_service)
     : service_weak_(extension_service->AsWeakPtr()),
-      prompt_for_plugins_(true) {
+      prompt_for_plugins_(true),
+      require_modern_manifest_version_(true) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 UnpackedInstaller::~UnpackedInstaller() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
         BrowserThread::CurrentlyOn(BrowserThread::FILE));
 }
 
 void UnpackedInstaller::Load(const FilePath& path_in) {
   extension_path_ = path_in;
   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
       base::Bind(&UnpackedInstaller::GetAbsolutePath, this));
 }
 
 void UnpackedInstaller::LoadFromCommandLine(const FilePath& path_in) {
   if (!service_weak_.get())
     return;
   // Load extensions from the command line synchronously to avoid a race
   // between extension loading and loading an URL from the command line.
   base::ThreadRestrictions::ScopedAllowIO allow_io;
 
   extension_path_ = path_in;
   file_util::AbsolutePath(&extension_path_);
 
   if (!IsLoadingUnpackedAllowed()) {
     ReportExtensionLoadError(kUnpackedExtensionsBlacklistedError);
     return;
   }
 
-  std::string id = Extension::GenerateIdForPath(extension_path_);
-  bool allow_file_access =
-      Extension::ShouldAlwaysAllowFileAccess(Extension::LOAD);
-  if (service_weak_->extension_prefs()->HasAllowFileAccessSetting(id))
-    allow_file_access = service_weak_->extension_prefs()->AllowFileAccess(id);
-
-  int flags = Extension::REQUIRE_MODERN_MANIFEST_VERSION;
-  if (allow_file_access)
-    flags |= Extension::ALLOW_FILE_ACCESS;
-
   std::string error;
   scoped_refptr<const Extension> extension(extension_file_util::LoadExtension(
       extension_path_,
       Extension::LOAD,
-      flags | Extension::FOLLOW_SYMLINKS_ANYWHERE,
+      GetFlags(),
       &error));
 
   if (!extension) {
     ReportExtensionLoadError(error);
     return;
   }
 
   OnLoaded(extension);
 }
 
+int UnpackedInstaller::GetFlags() {
+  std::string id = Extension::GenerateIdForPath(extension_path_);
+  bool allow_file_access =
+      Extension::ShouldAlwaysAllowFileAccess(Extension::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;
+}
+
 bool UnpackedInstaller::IsLoadingUnpackedAllowed() const {
   if (!service_weak_)
     return true;
   // If there is a "*" in the extension blacklist, then no extensions should be
   // allowed at all (except explicitly whitelisted extensions).
   return !service_weak_->extension_prefs()->ExtensionsBlacklistedByDefault();
 }
 
 void UnpackedInstaller::GetAbsolutePath() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   file_util::AbsolutePath(&extension_path_);
 
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
       base::Bind(&UnpackedInstaller::CheckExtensionFileAccess, this));
 }
 
 void UnpackedInstaller::CheckExtensionFileAccess() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!service_weak_)
     return;
 
   if (!IsLoadingUnpackedAllowed()) {
     ReportExtensionLoadError(kUnpackedExtensionsBlacklistedError);
     return;
   }
 
-  std::string id = Extension::GenerateIdForPath(extension_path_);
-  // Unpacked extensions default to allowing file access, but if that has been
-  // overridden, don't reset the value.
-  bool allow_file_access =
-      Extension::ShouldAlwaysAllowFileAccess(Extension::LOAD);
-  if (service_weak_->extension_prefs()->HasAllowFileAccessSetting(id))
-    allow_file_access = service_weak_->extension_prefs()->AllowFileAccess(id);
-
   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
       base::Bind(
-          &UnpackedInstaller::LoadWithFileAccess,
-          this, allow_file_access));
+          &UnpackedInstaller::LoadWithFileAccess, this, GetFlags()));
 }
 
-void UnpackedInstaller::LoadWithFileAccess(bool allow_file_access) {
+void UnpackedInstaller::LoadWithFileAccess(int flags) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-  int flags = Extension::REQUIRE_MODERN_MANIFEST_VERSION;
-  if (allow_file_access)
-    flags |= Extension::ALLOW_FILE_ACCESS;
+
   std::string error;
   scoped_refptr<const Extension> extension(extension_file_util::LoadExtension(
       extension_path_,
       Extension::LOAD,
-      flags | Extension::FOLLOW_SYMLINKS_ANYWHERE,
+      flags,
       &error));
 
   if (!extension) {
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
         base::Bind(
             &UnpackedInstaller::ReportExtensionLoadError,
             this, error));
     return;
   }
 
@@ skipping 30 matching lines @@
   }
 
   PermissionsUpdater perms_updater(service_weak_->profile());
   perms_updater.GrantActivePermissions(extension, false);
   service_weak_->OnExtensionInstalled(extension,
                                       false,  // Not from web store.
                                       StringOrdinal());
 }
 
 }  // namespace extensions