Home | History | Annotate | Download | only in extensions 
      1 // Copyright 2014 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "chrome/browser/extensions/zipfile_installer.h"
      6 
      7 #include "base/files/file_util.h"
      8 #include "base/path_service.h"
      9 #include "chrome/browser/extensions/extension_error_reporter.h"
     10 #include "chrome/browser/extensions/extension_service.h"
     11 #include "chrome/browser/extensions/unpacked_installer.h"
     12 #include "chrome/browser/profiles/profile.h"
     13 #include "chrome/common/extensions/chrome_utility_extensions_messages.h"
     14 #include "content/public/browser/browser_thread.h"
     15 #include "content/public/browser/utility_process_host.h"
     16 
     17 using content::BrowserThread;
     18 using content::UtilityProcessHost;
     19 
     20 namespace {
     21 
     22 const char kExtensionHandlerTempDirError[] =
     23     "Could not create temporary directory for zipped extension.";
     24 
     25 }  // namespace
     26 
     27 namespace extensions {
     28 
     29 ZipFileInstaller::ZipFileInstaller(ExtensionService* extension_service)
     30     : be_noisy_on_failure_(true),
     31       extension_service_weak_(extension_service->AsWeakPtr()) {
     32 }
     33 
     34 void ZipFileInstaller::LoadFromZipFile(const base::FilePath& path) {
     35   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     36   zip_path_ = path;
     37   BrowserThread::PostTask(BrowserThread::FILE,
     38                           FROM_HERE,
     39                           base::Bind(&ZipFileInstaller::PrepareTempDir, this));
     40 }
     41 
     42 void ZipFileInstaller::PrepareTempDir() {
     43   CHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
     44   base::FilePath temp_dir;
     45   PathService::Get(base::DIR_TEMP, &temp_dir);
     46   base::FilePath new_temp_dir;
     47   if (!base::CreateTemporaryDirInDir(
     48           temp_dir,
     49           zip_path_.RemoveExtension().BaseName().value() +
     50               FILE_PATH_LITERAL("_"),
     51           &new_temp_dir)) {
     52     OnUnzipFailed(std::string(kExtensionHandlerTempDirError));
     53     return;
     54   }
     55   BrowserThread::PostTask(
     56       BrowserThread::IO,
     57       FROM_HERE,
     58       base::Bind(&ZipFileInstaller::StartWorkOnIOThread, this, new_temp_dir));
     59 }
     60 
     61 ZipFileInstaller::~ZipFileInstaller() {
     62 }
     63 
     64 // static
     65 scoped_refptr<ZipFileInstaller> ZipFileInstaller::Create(
     66     ExtensionService* extension_service) {
     67   DCHECK(extension_service);
     68   return scoped_refptr<ZipFileInstaller>(
     69       new ZipFileInstaller(extension_service));
     70 }
     71 
     72 void ZipFileInstaller::StartWorkOnIOThread(const base::FilePath& temp_dir) {
     73   CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
     74   UtilityProcessHost* host =
     75       UtilityProcessHost::Create(this, base::MessageLoopProxy::current().get());
     76   host->SetExposedDir(temp_dir);
     77   host->Send(new ChromeUtilityMsg_UnzipToDir(zip_path_, temp_dir));
     78 }
     79 
     80 void ZipFileInstaller::ReportSuccessOnUIThread(
     81     const base::FilePath& unzipped_path) {
     82   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     83   if (extension_service_weak_.get())
     84     UnpackedInstaller::Create(extension_service_weak_.get())
     85         ->Load(unzipped_path);
     86 }
     87 
     88 void ZipFileInstaller::ReportErrorOnUIThread(const std::string& error) {
     89   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     90   if (extension_service_weak_.get()) {
     91     ExtensionErrorReporter::GetInstance()->ReportLoadError(
     92         zip_path_,
     93         error,
     94         extension_service_weak_->profile(),
     95         be_noisy_on_failure_);
     96   }
     97 }
     98 
     99 void ZipFileInstaller::OnUnzipSucceeded(const base::FilePath& unzipped_path) {
    100   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
    101   BrowserThread::PostTask(
    102       BrowserThread::UI,
    103       FROM_HERE,
    104       base::Bind(
    105           &ZipFileInstaller::ReportSuccessOnUIThread, this, unzipped_path));
    106 }
    107 
    108 void ZipFileInstaller::OnUnzipFailed(const std::string& error) {
    109   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
    110   BrowserThread::PostTask(
    111       BrowserThread::UI,
    112       FROM_HERE,
    113       base::Bind(&ZipFileInstaller::ReportErrorOnUIThread, this, error));
    114 }
    115 
    116 bool ZipFileInstaller::OnMessageReceived(const IPC::Message& message) {
    117   bool handled = true;
    118   IPC_BEGIN_MESSAGE_MAP(ZipFileInstaller, message)
    119   IPC_MESSAGE_HANDLER(ChromeUtilityHostMsg_UnzipToDir_Succeeded,
    120                       OnUnzipSucceeded)
    121   IPC_MESSAGE_HANDLER(ChromeUtilityHostMsg_UnzipToDir_Failed, OnUnzipFailed)
    122   IPC_MESSAGE_UNHANDLED(handled = false)
    123   IPC_END_MESSAGE_MAP()
    124   return handled;
    125 }
    126 
    127 }  // namespace extensions
    128