Prevent duplicate concurrent installs of the same extension

chrome/browser/extensions/webstore_standalone_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_standalone_installer.h"
 
 #include "base/values.h"
 #include "base/version.h"
 #include "chrome/browser/extensions/crx_installer.h"
 #include "chrome/browser/extensions/extension_install_prompt.h"
 #include "chrome/browser/extensions/extension_install_ui.h"
 #include "chrome/browser/extensions/extension_service.h"
+#include "chrome/browser/extensions/install_tracker.h"
 #include "chrome/browser/extensions/webstore_data_fetcher.h"
 #include "chrome/browser/profiles/profile.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/extension_util.h"
 #include "extensions/common/extension.h"
 #include "url/gurl.h"
 
 using content::WebContents;
 
 namespace extensions {
 
 const char kInvalidWebstoreItemId[] = "Invalid Chrome Web Store item ID";
 const char kWebstoreRequestError[] =
     "Could not fetch data from the Chrome Web Store";
 const char kInvalidWebstoreResponseError[] = "Invalid Chrome Web Store reponse";
 const char kInvalidManifestError[] = "Invalid manifest";
 const char kUserCancelledError[] = "User cancelled install";
 const char kExtensionIsBlacklisted[] = "Extension is blacklisted";
+const char kInstallInProgressError[] = "An install is already in progress";
+const char kLaunchInProgressError[] = "A launch is already in progress";
 
 WebstoreStandaloneInstaller::WebstoreStandaloneInstaller(
     const std::string& webstore_item_id,
     Profile* profile,
     const Callback& callback)
     : id_(webstore_item_id),
       callback_(callback),
       profile_(profile),
       install_source_(WebstoreInstaller::INSTALL_SOURCE_INLINE),
       show_user_count_(true),
       average_rating_(0.0),
       rating_count_(0) {
 }
 
 void WebstoreStandaloneInstaller::BeginInstall() {
   // Add a ref to keep this alive for WebstoreDataFetcher.
   // All code paths from here eventually lead to either CompleteInstall or
   // AbortInstall, which both release this ref.
   AddRef();
 
   if (!Extension::IdIsValid(id_)) {
     CompleteInstall(webstore_install::INVALID_ID, kInvalidWebstoreItemId);
     return;
   }
 
+  webstore_install::Result result = webstore_install::UNKNOWN_ERROR;
+  std::string error;
+  if (!EnsureUniqueInstall(&result, &error)) {
+    CompleteInstall(result, error);
+    return;
+  }
+
   // Use the requesting page as the referrer both since that is more correct
   // (it is the page that caused this request to happen) and so that we can
   // track top sites that trigger inline install requests.
   webstore_data_fetcher_.reset(new WebstoreDataFetcher(
       this,
       profile_->GetRequestContext(),
       GetRequestorURL(),
       id_));
   webstore_data_fetcher_->Start();
 }
 
 //
 // Private interface implementation.
 //
 
 WebstoreStandaloneInstaller::~WebstoreStandaloneInstaller() {
 }
 
 void WebstoreStandaloneInstaller::AbortInstall() {
   callback_.Reset();
   // Abort any in-progress fetches.
   if (webstore_data_fetcher_) {
     webstore_data_fetcher_.reset();
     Release();  // Matches the AddRef in BeginInstall.
   }
 }
 
+bool WebstoreStandaloneInstaller::EnsureUniqueInstall(
+    webstore_install::Result* reason,
+    std::string* error) {
+  InstallTracker* tracker = InstallTracker::Get(profile_);
+  DCHECK(tracker);
+
+  const ActiveInstallData* existing_install_data =
+      tracker->GetActiveInstall(id_);
+  if (existing_install_data) {
+    if (existing_install_data->is_ephemeral) {
+      *reason = webstore_install::LAUNCH_IN_PROGRESS;
+      *error = kLaunchInProgressError;
+    } else {
+      *reason = webstore_install::INSTALL_IN_PROGRESS;
+      *error = kInstallInProgressError;
+    }
+    return false;
+  }
+
+  ActiveInstallData install_data(id_);
+  InitInstallData(&install_data);
+  scoped_active_install_.reset(new ScopedActiveInstall(profile_, install_data));
+  return true;
+}
+
 void WebstoreStandaloneInstaller::CompleteInstall(
     webstore_install::Result result,
     const std::string& error) {
   if (!callback_.is_null())
     callback_.Run(result == webstore_install::SUCCESS, error);
   Release();  // Matches the AddRef in BeginInstall.
 }
 
 void WebstoreStandaloneInstaller::ProceedWithInstallPrompt() {
   install_prompt_ = CreateInstallPrompt();
@@ skipping 18 matching lines @@
             manifest_.get(),
             Extension::REQUIRE_KEY | Extension::FROM_WEBSTORE,
             id_,
             localized_name_,
             localized_description_,
             &error);
   }
   return localized_extension_for_display_.get();
 }
 
+void WebstoreStandaloneInstaller::InitInstallData(
+    ActiveInstallData* install_data) const {
+  // Default implementation sets no properties.
+}
+
 void WebstoreStandaloneInstaller::OnManifestParsed() {
   ProceedWithInstallPrompt();
 }
 
 scoped_ptr<ExtensionInstallPrompt>
 WebstoreStandaloneInstaller::CreateInstallUI() {
   return make_scoped_ptr(new ExtensionInstallPrompt(GetWebContents()));
 }
 
 scoped_ptr<WebstoreInstaller::Approval>
@@ skipping 255 matching lines @@
 void WebstoreStandaloneInstaller::OnWebStoreDataFetcherDone() {
   // An instance of this class is passed in as a delegate for the
   // WebstoreInstallHelper, ExtensionInstallPrompt and WebstoreInstaller, and
   // therefore needs to remain alive until they are done. Clear the webstore
   // data fetcher to avoid calling Release in AbortInstall while any of these
   // operations are in progress.
   webstore_data_fetcher_.reset();
 }
 
 }  // namespace extensions