Prevent duplicate concurrent installs of the same extension

chrome/browser/extensions/api/webstore_private/webstore_private_api.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/api/webstore_private/webstore_private_api.h"
 
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_vector.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "base/version.h"
 #include "chrome/browser/about_flags.h"
 #include "chrome/browser/apps/ephemeral_app_launcher.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/crx_installer.h"
 #include "chrome/browser/extensions/extension_service.h"
+#include "chrome/browser/extensions/install_tracker.h"
 #include "chrome/browser/extensions/webstore_installer.h"
 #include "chrome/browser/gpu/gpu_feature_checker.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/signin/signin_promo.h"
 #include "chrome/browser/signin/signin_tracker_factory.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/ui/app_list/app_list_service.h"
 #include "chrome/browser/ui/app_list/app_list_util.h"
@@ skipping 75 matching lines @@
     WebstoreInstaller::Approval* approval = approvals_[i];
     if (approval->extension_id == id &&
         profile->IsSameProfile(approval->profile)) {
       approvals_.weak_erase(approvals_.begin() + i);
       return scoped_ptr<WebstoreInstaller::Approval>(approval);
     }
   }
   return scoped_ptr<WebstoreInstaller::Approval>();
 }
 
-// Uniquely holds the profile and extension id of an install between the time we
-// prompt and complete the installs.
-class PendingInstalls {
- public:
-  PendingInstalls();
-  ~PendingInstalls();
-
-  bool InsertInstall(Profile* profile, const std::string& id);
-  void EraseInstall(Profile* profile, const std::string& id);
-  bool ContainsInstall(Profile* profile, const std::string& id);
- private:
-  typedef std::pair<Profile*, std::string> ProfileAndExtensionId;
-  typedef std::vector<ProfileAndExtensionId> InstallList;
-
-  InstallList::iterator FindInstall(Profile* profile, const std::string& id);
-
-  InstallList installs_;
-
-  DISALLOW_COPY_AND_ASSIGN(PendingInstalls);
-};
-
-PendingInstalls::PendingInstalls() {}
-PendingInstalls::~PendingInstalls() {}
-
-// Returns true and inserts the profile/id pair if it is not present. Otherwise
-// returns false.
-bool PendingInstalls::InsertInstall(Profile* profile, const std::string& id) {
-  if (FindInstall(profile, id) != installs_.end())
-    return false;
-  installs_.push_back(make_pair(profile, id));
-  return true;
-}
-
-// Removes the given profile/id pair.
-void PendingInstalls::EraseInstall(Profile* profile, const std::string& id) {
-  InstallList::iterator it = FindInstall(profile, id);
-  if (it != installs_.end())
-    installs_.erase(it);
-}
-
-bool PendingInstalls::ContainsInstall(Profile* profile, const std::string& id) {
-  return FindInstall(profile, id) != installs_.end();
-}
-
-PendingInstalls::InstallList::iterator PendingInstalls::FindInstall(
-    Profile* profile,
-    const std::string& id) {
-  for (size_t i = 0; i < installs_.size(); ++i) {
-    ProfileAndExtensionId install = installs_[i];
-    if (install.second == id && profile->IsSameProfile(install.first))
-      return (installs_.begin() + i);
-  }
-  return installs_.end();
-}
-
 static base::LazyInstance<PendingApprovals> g_pending_approvals =
     LAZY_INSTANCE_INITIALIZER;
-static base::LazyInstance<PendingInstalls> g_pending_installs =
-    LAZY_INSTANCE_INITIALIZER;
 
 // A preference set by the web store to indicate login information for
 // purchased apps.
 const char kWebstoreLogin[] = "extensions.webstore_login";
 const char kAlreadyInstalledError[] = "This item is already installed";
 const char kCannotSpecifyIconDataAndUrlError[] =
     "You cannot specify both icon data and an icon url";
 const char kInvalidIconUrlError[] = "Invalid icon url";
 const char kInvalidIdError[] = "Invalid id";
 const char kInvalidManifestError[] = "Invalid manifest";
@@ skipping 15 matching lines @@
 }
 
 void SetWebstoreLogin(Profile* profile, const std::string& login) {
   profile->GetPrefs()->SetString(kWebstoreLogin, login);
 }
 
 void RecordWebstoreExtensionInstallResult(bool success) {
   UMA_HISTOGRAM_BOOLEAN("Webstore.ExtensionInstallResult", success);
 }
 
+void RemoveActiveInstall(Profile* profile, const std::string& extension_id) {
+  InstallTracker* tracker = InstallTracker::Get(profile);
+  DCHECK(tracker);
+  tracker->RemoveActiveInstall(extension_id);
+}
+
 }  // namespace
 
 // static
 void WebstorePrivateApi::SetWebstoreInstallerDelegateForTesting(
     WebstoreInstaller::Delegate* delegate) {
   test_webstore_installer_delegate = delegate;
 }
 
 // static
 scoped_ptr<WebstoreInstaller::Approval>
@@ skipping 96 matching lines @@
   }
 
   if (params_->details.authuser) {
     authuser_ = *params_->details.authuser;
   }
 
   std::string icon_data = params_->details.icon_data ?
       *params_->details.icon_data : std::string();
 
   Profile* profile = GetProfile();
+  InstallTracker* tracker = InstallTracker::Get(profile);
+  DCHECK(tracker);
   if (util::IsExtensionInstalledPermanently(params_->details.id, profile) ||
-      !g_pending_installs.Get().InsertInstall(profile, params_->details.id)) {
+      tracker->GetActiveInstall(params_->details.id)) {
     SetResultCode(ALREADY_INSTALLED);
     error_ = kAlreadyInstalledError;
     return false;
   }
+  InstallTracker::InstallProgressData install_data(params_->details.id);
+  tracker->AddActiveInstall(install_data);
 
   net::URLRequestContextGetter* context_getter = NULL;
   if (!icon_url.is_empty())
     context_getter = GetProfile()->GetRequestContext();
 
   scoped_refptr<WebstoreInstallHelper> helper = new WebstoreInstallHelper(
       this, params_->details.id, params_->details.manifest, icon_data, icon_url,
           context_getter);
 
   // The helper will call us back via OnWebstoreParseSuccess or
@@ skipping 98 matching lines @@
     case WebstoreInstallHelper::Delegate::ICON_ERROR:
       SetResultCode(ICON_ERROR);
       break;
     case WebstoreInstallHelper::Delegate::MANIFEST_ERROR:
       SetResultCode(MANIFEST_ERROR);
       break;
     default:
       CHECK(false);
   }
   error_ = error_message;
-  g_pending_installs.Get().EraseInstall(GetProfile(), id);
+  RemoveActiveInstall(GetProfile(), id);
   SendResponse(false);
 
   // Matches the AddRef in RunAsync().
   Release();
 }
 
 void WebstorePrivateBeginInstallWithManifest3Function::SigninFailed(
     const GoogleServiceAuthError& error) {
   signin_tracker_.reset();
 
   SetResultCode(SIGNIN_FAILED);
   error_ = error.ToString();
-  g_pending_installs.Get().EraseInstall(GetProfile(), params_->details.id);
+  RemoveActiveInstall(GetProfile(), params_->details.id);

[asargent_no_longer_on_chrome, 2014/07/16 18:49:07]

It would be cool if we had something like a "ScopedActiveInstall" object for the
install tracker, so that we wouldn't have to remember to call
RemoveActiveInstall everywhere - it would automatically get removed when the
ScopedActiveInstall was deleted. 

[tmdiep, 2014/07/17 01:01:51]

That's a great idea. Done.

The WebstorePrivateAPI install is split between beginInstall and
completeInstall, so that explains ScopedActiveInstall::CancelDeregister().

   SendResponse(false);
 
   // Matches the AddRef in RunAsync().
   Release();
 }
 
 void WebstorePrivateBeginInstallWithManifest3Function::SigninSuccess() {
   signin_tracker_.reset();
 
   SigninCompletedOrNotNeeded();
@@ skipping 47 matching lines @@
       dummy_extension_.get(), "Extensions.Permissions_WebStoreInstall2");
 
   // Matches the AddRef in RunAsync().
   Release();
 }
 
 void WebstorePrivateBeginInstallWithManifest3Function::InstallUIAbort(
     bool user_initiated) {
   error_ = kUserCancelledError;
   SetResultCode(USER_CANCELLED);
-  g_pending_installs.Get().EraseInstall(GetProfile(), params_->details.id);
+  RemoveActiveInstall(GetProfile(), params_->details.id);
   SendResponse(false);
 
   // The web store install histograms are a subset of the install histograms.
   // We need to record both histograms here since CrxInstaller::InstallUIAbort
   // is never called for web store install cancellations.
   std::string histogram_name =
       user_initiated ? "Extensions.Permissions_WebStoreInstallCancel2"
                      : "Extensions.Permissions_WebStoreInstallAbort2";
   ExtensionService::RecordPermissionMessagesHistogram(dummy_extension_.get(),
                                                       histogram_name.c_str());
@@ skipping 94 matching lines @@
     const std::string& id,
     const std::string& error,
     WebstoreInstaller::FailureReason reason) {
   if (test_webstore_installer_delegate) {
     test_webstore_installer_delegate->OnExtensionInstallFailure(
         id, error, reason);
   }
 
   error_ = error;
   VLOG(1) << "Install failed, sending response";
-  g_pending_installs.Get().EraseInstall(GetProfile(), id);
+  RemoveActiveInstall(GetProfile(), id);
   SendResponse(false);
 
   RecordWebstoreExtensionInstallResult(false);
 
   // Matches the AddRef in RunAsync().
   Release();
 }
 
 void WebstorePrivateCompleteInstallFunction::OnInstallSuccess(
     const std::string& id) {
   if (test_webstore_installer_delegate)
     test_webstore_installer_delegate->OnExtensionInstallSuccess(id);
 
   VLOG(1) << "Install success, sending response";
-  g_pending_installs.Get().EraseInstall(GetProfile(), id);
+  RemoveActiveInstall(GetProfile(), id);
   SendResponse(true);
 }
 
 WebstorePrivateEnableAppLauncherFunction::
     WebstorePrivateEnableAppLauncherFunction() {}
 
 WebstorePrivateEnableAppLauncherFunction::
     ~WebstorePrivateEnableAppLauncherFunction() {}
 
 bool WebstorePrivateEnableAppLauncherFunction::RunSync() {
@@ skipping 174 matching lines @@
   if (!user_gesture()) {
     SetResult(LaunchEphemeralAppResult::RESULT_USER_GESTURE_REQUIRED,
               "User gesture is required");
     return false;
   }
 
   scoped_ptr<LaunchEphemeralApp::Params> params(
       LaunchEphemeralApp::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
-  // If a full install is in progress, do not install ephemerally.
-  if (g_pending_installs.Get().ContainsInstall(GetProfile(), params->id)) {
-    SetResult(LaunchEphemeralAppResult::RESULT_INSTALL_IN_PROGRESS,
-              "An install is already in progress");
-    return false;
-  }
-
   AddRef();  // Balanced in OnLaunchComplete()
 
   scoped_refptr<EphemeralAppLauncher> launcher =
       EphemeralAppLauncher::CreateForWebContents(
           params->id,
           web_contents,
           base::Bind(
               &WebstorePrivateLaunchEphemeralAppFunction::OnLaunchComplete,
               base::Unretained(this)));
   launcher->Start();
@@ skipping 36 matching lines @@
       break;
     case webstore_install::BLOCKED_BY_POLICY:
       api_result = LaunchEphemeralAppResult::RESULT_BLOCKED_BY_POLICY;
       break;
     case webstore_install::LAUNCH_FEATURE_DISABLED:
       api_result = LaunchEphemeralAppResult::RESULT_FEATURE_DISABLED;
       break;
     case webstore_install::LAUNCH_UNSUPPORTED_EXTENSION_TYPE:
       api_result = LaunchEphemeralAppResult::RESULT_UNSUPPORTED_EXTENSION_TYPE;
       break;
+    case webstore_install::INSTALL_IN_PROGRESS:
+      api_result = LaunchEphemeralAppResult::RESULT_INSTALL_IN_PROGRESS;
+      break;
+    case webstore_install::LAUNCH_IN_PROGRESS:
+      api_result = LaunchEphemeralAppResult::RESULT_LAUNCH_IN_PROGRESS;
+      break;
     default:
       NOTREACHED();
       break;
   }
 
   SetResult(api_result, error);
   Release();  // Matches AddRef() in RunAsync()
 }
 
 void WebstorePrivateLaunchEphemeralAppFunction::SetResult(
@@ skipping 20 matching lines @@
 WebstorePrivateGetEphemeralAppsEnabledFunction::
     ~WebstorePrivateGetEphemeralAppsEnabledFunction() {}
 
 bool WebstorePrivateGetEphemeralAppsEnabledFunction::RunSync() {
   results_ = GetEphemeralAppsEnabled::Results::Create(
       EphemeralAppLauncher::IsFeatureEnabled());
   return true;
 }
 
 }  // namespace extensions