Create CrxInstaller directly in WebstoreInstaller

chrome/browser/extensions/webstore_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/webstore_installer.h"
 
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 318 matching lines @@
 }
 
 void WebstoreInstaller::Observe(int type,
                                 const content::NotificationSource& source,
                                 const content::NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_CRX_INSTALLER_DONE: {
       const Extension* extension =
           content::Details<const Extension>(details).ptr();
       CrxInstaller* installer = content::Source<CrxInstaller>(source).ptr();
-      if (extension == NULL && download_item_ != NULL &&
-          installer->download_url() == download_item_->GetURL() &&
-          installer->profile()->IsSameProfile(profile_)) {
-        ReportFailure(kInstallCanceledError, FAILURE_REASON_CANCELLED);
+      if (crx_installer_.get() == installer) {
+        if (extension == NULL)
+          ReportFailure(kInstallCanceledError, FAILURE_REASON_CANCELLED);
+        crx_installer_ = NULL;
       }
       break;
     }
 
     case chrome::NOTIFICATION_EXTENSION_INSTALLED: {
       CHECK(profile_->IsSameProfile(content::Source<Profile>(source).ptr()));
       const Extension* extension =
           content::Details<const InstalledExtensionInfo>(details)->extension;
       if (pending_modules_.empty())
         return;
@@ skipping 21 matching lines @@
         } else {
           DownloadNextPendingModule();
         }
       }
       break;
     }
 
     case chrome::NOTIFICATION_EXTENSION_INSTALL_ERROR: {
       CrxInstaller* crx_installer = content::Source<CrxInstaller>(source).ptr();
       CHECK(crx_installer);
-      if (!profile_->IsSameProfile(crx_installer->profile()))
+      if (crx_installer != crx_installer_.get())
         return;
 
       // TODO(rdevlin.cronin): Continue removing std::string errors and
       // replacing with base::string16. See crbug.com/71980.
       const base::string16* error =
           content::Details<const base::string16>(details).ptr();
       const std::string utf8_error = base::UTF16ToUTF8(*error);
-      if (download_url_ == crx_installer->original_download_url())
-        ReportFailure(utf8_error, FAILURE_REASON_OTHER);
+      ReportFailure(utf8_error, FAILURE_REASON_OTHER);
+      crx_installer_ = NULL;
       break;
     }
 
     default:
       NOTREACHED();
   }
 }
 
 void WebstoreInstaller::InvalidateDelegate() {
   delegate_ = NULL;
@@ skipping 59 matching lines @@
       ReportFailure(kDownloadCanceledError, FAILURE_REASON_CANCELLED);
       break;
     case DownloadItem::INTERRUPTED:
       RecordInterrupt(download);
       ReportFailure(kDownloadInterruptedError, FAILURE_REASON_OTHER);
       break;
     case DownloadItem::COMPLETE:
       // Wait for other notifications if the download is really an extension.
       if (!download_crx_util::IsExtensionDownload(*download)) {
         ReportFailure(kInvalidDownloadError, FAILURE_REASON_OTHER);
-      } else if (pending_modules_.empty()) {
-        // The download is the last module - the extension main module.
-        if (delegate_)
-          delegate_->OnExtensionDownloadProgress(id_, download);
-        extensions::InstallTracker* tracker =
-            extensions::InstallTrackerFactory::GetForProfile(profile_);
-        tracker->OnDownloadProgress(id_, 100);
+      } else {
+        if (crx_installer_.get())
+          return;  // DownloadItemImpl calls the observer twice, ignore it.
+        StartCrxInstaller(*download);
+
+        if (pending_modules_.empty()) {
+          // The download is the last module - the extension main module.
+          if (delegate_)
+            delegate_->OnExtensionDownloadProgress(id_, download);
+          extensions::InstallTracker* tracker =
+              extensions::InstallTrackerFactory::GetForProfile(profile_);
+          tracker->OnDownloadProgress(id_, 100);
+        }
       }
       // Stop the progress timer if it's running.
       download_progress_timer_.Stop();
       break;
     case DownloadItem::IN_PROGRESS: {
       if (delegate_ && pending_modules_.size() == 1) {
         // Only report download progress for the main module to |delegrate_|.
         delegate_->OnExtensionDownloadProgress(id_, download);
       }
       UpdateDownloadProgress();
@@ skipping 152 matching lines @@
     download_progress_timer_.Start(
         FROM_HERE,
         base::TimeDelta::FromSeconds(kTimeRemainingMinutesThreshold),
         this,
         &WebstoreInstaller::UpdateDownloadProgress);
   } else {
     download_progress_timer_.Stop();
   }
 }
 
+void WebstoreInstaller::StartCrxInstaller(const DownloadItem& download) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(!crx_installer_.get());
+
+  ExtensionService* service = ExtensionSystem::Get(profile_)->
+      extension_service();
+  CHECK(service);
+
+  const Approval* approval = GetAssociatedApproval(download);
+  DCHECK(approval);
+
+  crx_installer_ = download_crx_util::CreateCrxInstaller(profile_, download);
+
+  crx_installer_->set_error_on_unsupported_requirements(true);
+  crx_installer_->set_delete_source(true);
+  crx_installer_->set_install_cause(
+      extension_misc::INSTALL_CAUSE_USER_DOWNLOAD);
+  crx_installer_->set_original_mime_type(download.GetOriginalMimeType());
+  crx_installer_->set_apps_require_extension_mime_type(true);
+  crx_installer_->set_expected_id(approval->extension_id);
+  crx_installer_->set_is_gallery_install(true);
+  crx_installer_->set_allow_silent_install(true);
+
+  crx_installer_->InstallCrx(download.GetFullPath());
+}
+
 void WebstoreInstaller::ReportFailure(const std::string& error,
                                       FailureReason reason) {
   if (delegate_) {
     delegate_->OnExtensionInstallFailure(id_, error, reason);
     delegate_ = NULL;
   }
 
   extensions::InstallTracker* tracker =
       extensions::InstallTrackerFactory::GetForProfile(profile_);
   tracker->OnInstallFailure(id_);
@@ skipping 31 matching lines @@
         1,
         kMaxSizeKb,
         kNumBuckets);
   }
   UMA_HISTOGRAM_BOOLEAN(
       "Extensions.WebstoreDownload.InterruptTotalSizeUnknown",
       total_bytes <= 0);
 }
 
 }  // namespace extensions