Allow drag-and-drop of zipped extensions on chrome://extensions

chrome/browser/extensions/unpacked_installer.cc

 // Copyright (c) 2013 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/command_line.h"
 #include "base/file_util.h"
@@ skipping 10 matching lines @@
 #include "content/public/browser/browser_thread.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/install_flag.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_l10n_util.h"
 #include "extensions/common/file_util.h"
 #include "extensions/common/id_util.h"
 #include "extensions/common/manifest.h"
 #include "sync/api/string_ordinal.h"
+#include "third_party/zlib/google/zip.h"
 
 using content::BrowserThread;
 using extensions::Extension;
 
 namespace {
 
 const char kUnpackedExtensionsBlacklistedError[] =
     "Loading of unpacked extensions is disabled by the administrator.";
+const char kUnpackedInstallerTempDirError[] =
+    "Could not create temporary directory for zipped extension.";
+const char kUnpackedInstallerUnzipError[] =
+    "Could not unzip extension for install.";
 
 // Manages an ExtensionInstallPrompt for a particular extension.
 class SimpleExtensionLoadPrompt : public ExtensionInstallPrompt::Delegate {
  public:
   SimpleExtensionLoadPrompt(const Extension* extension,
                             Profile* profile,
                             const base::Closure& callback);
   virtual ~SimpleExtensionLoadPrompt();
 
   void ShowPrompt();
@@ skipping 112 matching lines @@
     ReportExtensionLoadError(error);
     return false;
   }
 
   ShowInstallPrompt();
 
   *extension_id = extension()->id();
   return true;
 }
 
+void UnpackedInstaller::LoadFromZipFile(const base::FilePath& zip_path) {
+  BrowserThread::PostTask(
+      BrowserThread::FILE,
+      FROM_HERE,
+      base::Bind(&UnpackedInstaller::UnpackZipFileAndLoad, this, zip_path));
+}
+
+void UnpackedInstaller::UnpackZipFileAndLoad(const base::FilePath& zip_path) {
+  CHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  base::FilePath temp_path;
+  if (!base::CreateTemporaryDirInDir(

[elijahtaylor1, 2014/07/18 23:47:43]

I didn't know of a great way to notify the user/developer that the dir is being
created, but since it is created along-side the original zip file I thought it
would be ok.

[asargent_no_longer_on_chrome, 2014/07/22 22:51:01]

I wonder if it would be better to unzip into a new directory created within the
system temporary directory?

We do show the location the item was loaded from in chrome://extensions, with a
clickable link to open up the native file manager program pointing at that
directory. 

[elijahtaylor1, 2014/07/23 00:19:07]

It's probably better to do in a temp dir, but it could lead to the Preferences
pollution we talked about (I guess that could happen in either case).  I will do
this in a future patchset, just want to get security to weigh in first

+          zip_path.DirName(),
+          zip_path.RemoveExtension().BaseName().value() +
+              FILE_PATH_LITERAL("_"),
+          &temp_path)) {
+    // Set extension_path_ so a meaningful error is displayed, it would normally
+    // be set by UnpackedInstaller::Load
+    extension_path_ = zip_path;
+    BrowserThread::PostTask(
+        BrowserThread::UI,
+        FROM_HERE,
+        base::Bind(&UnpackedInstaller::ReportExtensionLoadError,
+                   this,
+                   kUnpackedInstallerTempDirError));
+    return;
+  }
+  if (!zip::Unzip(zip_path, temp_path)) {

[asargent_no_longer_on_chrome, 2014/07/22 22:51:01]

For regular extension installation, we do the unzipping operation in a sandboxed
helper process to help mitigate exploits of security bugs in the zip format
library code. It might be worth asking someone on the security team like meacer@
if they think we should do the same here.

[elijahtaylor1, 2014/07/23 00:19:07]

Yeah, I first tried to use the sandboxed unpacker, but it was really specific to
unpacking a CRX for side-loading, and I didn't want to modify that code to do
this.  I'll check with security

[meacer, 2014/07/23 00:32:15]

I agree with Antony, it's best to do this in the sandboxed unpacker. I think you
should be able to refactor it for your purposes?

+    // Set extension_path_ so a meaningful error is displayed, it would normally
+    // be set by UnpackedInstaller::Load
+    extension_path_ = zip_path;
+    BrowserThread::PostTask(
+        BrowserThread::UI,
+        FROM_HERE,
+        base::Bind(&UnpackedInstaller::ReportExtensionLoadError,
+                   this,
+                   kUnpackedInstallerUnzipError));
+    return;
+  }
+  Load(temp_path);
+}
+
 void UnpackedInstaller::ShowInstallPrompt() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!service_weak_.get())
     return;
 
   const ExtensionSet& disabled_extensions =
       ExtensionRegistry::Get(service_weak_->profile())->disabled_extensions();
   if (service_weak_->show_extensions_prompts() && prompt_for_plugins_ &&
       PluginInfo::HasPlugins(extension()) &&
       !disabled_extensions.Contains(extension()->id())) {
@@ skipping 132 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   PermissionsUpdater perms_updater(service_weak_->profile());
   perms_updater.GrantActivePermissions(extension());
 
   service_weak_->OnExtensionInstalled(
       extension(), syncer::StringOrdinal(), kInstallFlagInstallImmediately);
 }
 
 }  // namespace extensions