Add chrome.webstore API methods to allow sites to see progress of installation

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"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/path_service.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/time/time.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/download/download_crx_util.h"
 #include "chrome/browser/download/download_prefs.h"
 #include "chrome/browser/download/download_stats.h"
 #include "chrome/browser/extensions/crx_installer.h"
 #include "chrome/browser/extensions/install_tracker.h"
 #include "chrome/browser/extensions/install_tracker_factory.h"
 #include "chrome/browser/extensions/install_verifier.h"
 #include "chrome/browser/omaha_query_params/omaha_query_params.h"
 #include "chrome/browser/profiles/profile.h"
@@ skipping 45 matching lines @@
 const char kDownloadInterruptedError[] = "Download interrupted";
 const char kInvalidDownloadError[] =
     "Download was not a valid extension or user script";
 const char kDependencyNotFoundError[] = "Dependency not found";
 const char kDependencyNotSharedModuleError[] =
     "Dependency is not shared module";
 const char kInlineInstallSource[] = "inline";
 const char kDefaultInstallSource[] = "ondemand";
 const char kAppLauncherInstallSource[] = "applauncher";
 
+const size_t kTimeRemainingMinutesThreshold = 1u;
+
 // Folder for downloading crx files from the webstore. This is used so that the
 // crx files don't go via the usual downloads folder.
 const base::FilePath::CharType kWebstoreDownloadFolder[] =
     FILE_PATH_LITERAL("Webstore Downloads");
 
 base::FilePath* g_download_directory_for_tests = NULL;
 
 // Must be executed on the FILE thread.
 void GetDownloadFilePath(
     const base::FilePath& download_directory,
@@ skipping 199 matching lines @@
 
   total_modules_ = pending_modules_.size();
 
   std::set<std::string> ids;
   std::list<SharedModuleInfo::ImportInfo>::const_iterator i;
   for (i = pending_modules_.begin(); i != pending_modules_.end(); ++i) {
     ids.insert(i->extension_id);
   }
   ExtensionSystem::Get(profile_)->install_verifier()->AddProvisional(ids);
 
-  // TODO(crbug.com/305343): Query manifest of dependencises before
-  // downloading & installing those dependencies.
-  DownloadNextPendingModule();
-
   std::string name;
   if (!approval_->manifest->value()->GetString(manifest_keys::kName, &name)) {
     NOTREACHED();
   }
   extensions::InstallTracker* tracker =
       extensions::InstallTrackerFactory::GetForProfile(profile_);
   extensions::InstallObserver::ExtensionInstallParams params(
       id_,
       name,
       approval_->installing_icon,
       approval_->manifest->is_app(),
       approval_->manifest->is_platform_app());
   params.is_ephemeral = approval_->is_ephemeral;
   tracker->OnBeginExtensionInstall(params);
+
+  tracker->OnBeginExtensionDownload(id_);
+
+  // TODO(crbug.com/305343): Query manifest of dependencies before
+  // downloading & installing those dependencies.
+  DownloadNextPendingModule();
 }
 
 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();
@@ skipping 132 matching lines @@
       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);
       }
+      // 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);
       }
-      int percent = download->PercentComplete();
-      // Only report progress if precent is more than 0
-      if (percent >= 0) {
-        int finished_modules = total_modules_ - pending_modules_.size();
-        percent = (percent + finished_modules * 100) / total_modules_;
-        extensions::InstallTracker* tracker =
-          extensions::InstallTrackerFactory::GetForProfile(profile_);
-        tracker->OnDownloadProgress(id_, percent);
-      }
+      UpdateDownloadProgress();
       break;
     }
     default:
       // Continue listening if the download is not in one of the above states.
       break;
   }
 }
 
 void WebstoreInstaller::OnDownloadDestroyed(DownloadItem* download) {
   CHECK_EQ(download_item_, download);
@@ skipping 106 matching lines @@
       resource_context));
   params->set_file_path(file);
   if (controller.GetVisibleEntry())
     params->set_referrer(
         content::Referrer(controller.GetVisibleEntry()->GetURL(),
                           blink::WebReferrerPolicyDefault));
   params->set_callback(base::Bind(&WebstoreInstaller::OnDownloadStarted, this));
   download_manager->DownloadUrl(params.Pass());
 }
 
+void WebstoreInstaller::UpdateDownloadProgress() {
+  // If the download has gone away, or isn't in progress (in which case we can't
+  // give a good progress estimate), stop any running timers and return.
+  if (!download_item_ ||
+      download_item_->GetState() != DownloadItem::IN_PROGRESS) {
+    download_progress_timer_.Stop();
+    return;
+  }
+
+  int percent = download_item_->PercentComplete();
+  // Only report progress if precent is more than 0
+  if (percent >= 0) {
+    int finished_modules = total_modules_ - pending_modules_.size();
+    percent = (percent + (finished_modules * 100)) / total_modules_;
+    extensions::InstallTracker* tracker =
+        extensions::InstallTrackerFactory::GetForProfile(profile_);
+    tracker->OnDownloadProgress(id_, percent);
+  }
+
+  // If there's enough time remaining on the download to warrant an update,
+  // set the timer (overwriting any current timers). Otherwise, stop the
+  // timer.
+  base::TimeDelta time_remaining;
+  if (download_item_->TimeRemaining(&time_remaining) &&
+      time_remaining >
+          base::TimeDelta::FromSeconds(kTimeRemainingMinutesThreshold)) {
+    download_progress_timer_.Start(
+        FROM_HERE,
+        base::TimeDelta::FromSeconds(kTimeRemainingMinutesThreshold),
+        this,
+        &WebstoreInstaller::UpdateDownloadProgress);
+  } else {
+    download_progress_timer_.Stop();
+  }
+}
+
 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