Add a commandline flag to chrome to validate crx files

chrome/browser/extensions/startup_helper.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/startup_helper.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
+#include "base/files/file_path.h"
 #include "base/message_loop.h"
+#include "base/run_loop.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/extensions/extension_service.h"
+#include "chrome/browser/extensions/sandboxed_unpacker.h"
 #include "chrome/browser/extensions/webstore_startup_installer.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/api/i18n/default_locale_handler.h"
 #include "chrome/common/extensions/background_info.h"
 #include "chrome/common/extensions/extension.h"
+#include "content/public/browser/browser_thread.h"
 #include "content/public/browser/web_contents.h"
 #include "ipc/ipc_message.h"
 
+using content::BrowserThread;
+
 namespace {
 
 void PrintPackExtensionMessage(const std::string& message) {
   printf("%s\n", message.c_str());
 }
 
 }  // namespace
 
 namespace extensions {
 
@@ skipping 32 matching lines @@
   // Launch a job to perform the packing on the file thread.  Ignore warnings
   // from the packing process. (e.g. Overwrite any existing crx file.)
   pack_job_ = new PackExtensionJob(this, src_dir, private_key_path,
                                    ExtensionCreator::kOverwriteCRX);
   pack_job_->set_asynchronous(false);
   pack_job_->Start();
 
   return pack_job_succeeded_;
 }
 
+namespace {
+
+class ValidateCrxHelper : public SandboxedUnpackerClient {
+ public:
+  ValidateCrxHelper(const base::FilePath& crx_file,
+                    const base::FilePath& temp_dir,
+                    base::RunLoop* run_loop)
+      : crx_file_(crx_file), temp_dir_(temp_dir), run_loop_(run_loop),
+        finished_(false), success_(false) {}
+
+  bool finished() { return finished_; }
+  bool success() { return success_; }
+  const string16& error() { return error_; }
+
+  void Start() {
+    BrowserThread::PostTask(BrowserThread::FILE,
+                            FROM_HERE,
+                            base::Bind(&ValidateCrxHelper::StartOnFileThread,
+                                       this));
+  }
+
+ protected:
+  virtual ~ValidateCrxHelper() {}
+
+  virtual void OnUnpackSuccess(const base::FilePath& temp_dir,
+                               const base::FilePath& extension_root,
+                               const base::DictionaryValue* original_manifest,
+                               const Extension* extension) {
+    finished_ = true;
+    success_ = true;
+    BrowserThread::PostTask(BrowserThread::UI,
+                            FROM_HERE,
+                            base::Bind(&ValidateCrxHelper::FinishOnUIThread,
+                                       this));
+  }
+
+  virtual void OnUnpackFailure(const string16& error) {
+    finished_ = true;
+    success_ = false;
+    error_ = error;
+    BrowserThread::PostTask(BrowserThread::UI,
+                            FROM_HERE,
+                            base::Bind(&ValidateCrxHelper::FinishOnUIThread,
+                                       this));
+  }
+
+  void FinishOnUIThread() {
+    CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    if (run_loop_->running())
+      run_loop_->Quit();
+  }
+
+  void StartOnFileThread() {
+    CHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+    scoped_refptr<base::MessageLoopProxy> file_thread_proxy =
+        BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE);
+
+    scoped_refptr<SandboxedUnpacker> unpacker(
+        new SandboxedUnpacker(crx_file_,
+                              true /* out of process */,
+                              Manifest::INTERNAL,
+                              0, /* no special creation flags */
+                              temp_dir_,
+                              file_thread_proxy,
+                              this));
+    unpacker->Start();
+  }
+
+  // The file being validated.
+  const base::FilePath& crx_file_;
+
+  // The temporary directory where the sandboxed unpacker will do work.
+  const base::FilePath& temp_dir_;
+
+  // Unowned pointer to a runloop, so our consumer can wait for us to finish.
+  base::RunLoop* run_loop_;
+
+  // Whether we're finished unpacking;
+  bool finished_;
+
+  // Whether the unpacking was successful.
+  bool success_;
+
+  // If the unpacking wasn't successful, this contains an error message.
+  string16 error_;
+};
+
+}  // namespace
+
+bool StartupHelper::ValidateCrx(const CommandLine& cmd_line) {
+  base::FilePath path = cmd_line.GetSwitchValuePath(switches::kValidateCrx);
+  if (path.empty()) {
+    LOG(ERROR) << "Empty path passed for " << switches::kValidateCrx;
+    return false;
+  }
+  base::ScopedTempDir temp_dir;
+
+  if (!temp_dir.CreateUniqueTempDir()) {
+    LOG(ERROR) << "Failed to create temp dir";
+    return false;
+  }
+
+  base::RunLoop run_loop;
+  scoped_refptr<ValidateCrxHelper> helper(
+      new ValidateCrxHelper(path, temp_dir.path(), &run_loop));
+  helper->Start();
+  if (!helper->finished())
+    run_loop.Run();
+
+  bool success = helper->success();
+  if (success)

[asargent_no_longer_on_chrome, 2013/03/20 17:43:47]

Just using LOG(ERROR) here to report both success and failure feels pretty lame,
but I didn't see any convenient way of doing something better. Let me know if
you have any ideas. 

[Matt Perry, 2013/03/20 19:52:15]

This is intended to be used as an automated tool by the webstore, right? It
seems like it'll be ugly for them to parse through log output to find the
success/error code. Maybe they have a better idea of a technique that would be
good for them. Passing in a named pipe filename, for example.

[asargent_no_longer_on_chrome, 2013/03/21 21:34:44]

As we discussed offline, I've switched this to just printing success/failure to
stdout so they can easily filter out any unrelated LOG(ERROR) cruft that goes to
stderr.

+    LOG(ERROR) << "ValidateCrx Success: '" << path.LossyDisplayName()
+               << "' is valid";
+  else
+    LOG(ERROR) << "ValidateCrx Error: '" << path.LossyDisplayName()
+               << "' is invalid. Details: '" << helper->error() << "'";
+  return success;
+}
+
 bool StartupHelper::UninstallExtension(const CommandLine& cmd_line,
                                        Profile* profile) {
   DCHECK(profile);
 
   if (!cmd_line.HasSwitch(switches::kUninstallExtension))
     return false;
 
   ExtensionService* extension_service = profile->GetExtensionService();
   if (!extension_service)
     return false;
@@ skipping 124 matching lines @@
   }
   return id;
 }
 
 StartupHelper::~StartupHelper() {
   if (pack_job_.get())
     pack_job_->ClearClient();
 }
 
 }  // namespace extensions