Prevent duplicate webstore install requests being serviced.

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 "apps/app_launcher.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
@@ skipping 34 matching lines @@
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using content::GpuDataManager;
 
 namespace extensions {
 
 namespace {
 
 // Holds the Approvals between the time we prompt and start the installs.
-struct PendingApprovals {
-  typedef ScopedVector<WebstoreInstaller::Approval> ApprovalList;
-
+class PendingApprovals {
+ public:
   PendingApprovals();
   ~PendingApprovals();
 
   void PushApproval(scoped_ptr<WebstoreInstaller::Approval> approval);
   scoped_ptr<WebstoreInstaller::Approval> PopApproval(
       Profile* profile, const std::string& id);
+ private:
+  typedef ScopedVector<WebstoreInstaller::Approval> ApprovalList;
 
-  ApprovalList approvals;
+  ApprovalList approvals_;
+
+  DISALLOW_COPY_AND_ASSIGN(PendingApprovals);
 };
 
 PendingApprovals::PendingApprovals() {}
 PendingApprovals::~PendingApprovals() {}
 
 void PendingApprovals::PushApproval(
     scoped_ptr<WebstoreInstaller::Approval> approval) {
-  approvals.push_back(approval.release());
+  approvals_.push_back(approval.release());
 }
 
 scoped_ptr<WebstoreInstaller::Approval> PendingApprovals::PopApproval(
     Profile* profile, const std::string& id) {
-  for (size_t i = 0; i < approvals.size(); ++i) {
-    WebstoreInstaller::Approval* approval = approvals[i];
+  for (size_t i = 0; i < approvals_.size(); ++i) {
+    WebstoreInstaller::Approval* approval = approvals_[i];
     if (approval->extension_id == id &&
         profile->IsSameProfile(approval->profile)) {
-      approvals.weak_erase(approvals.begin() + i);
+      approvals_.weak_erase(approvals_.begin() + i);
       return scoped_ptr<WebstoreInstaller::Approval>(approval);
     }
   }
   return scoped_ptr<WebstoreInstaller::Approval>(NULL);
 }
 
+// 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);
+ 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);
+}
+
+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;
 
 const char kAppInstallBubbleKey[] = "appInstallBubble";
 const char kEnableLauncherKey[] = "enableLauncher";
 const char kIconDataKey[] = "iconData";
 const char kIconUrlKey[] = "iconUrl";
 const char kIdKey[] = "id";
 const char kLocalizedNameKey[] = "localizedName";
 const char kLoginKey[] = "login";
 const char kManifestKey[] = "manifest";
 
 // 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";
 const char kNoPreviousBeginInstallWithManifestError[] =
     "* does not match a previous call to beginInstallWithManifest3";
 const char kUserCancelledError[] = "User cancelled install";
 
 // Helper to create a dictionary with login properties set from the appropriate
@@ skipping 155 matching lines @@
                                                    &localized_name_));
 
   if (details->HasKey(kAppInstallBubbleKey))
     EXTENSION_FUNCTION_VALIDATE(details->GetBoolean(
         kAppInstallBubbleKey, &use_app_installed_bubble_));
 
   if (details->HasKey(kEnableLauncherKey))
     EXTENSION_FUNCTION_VALIDATE(details->GetBoolean(
         kEnableLauncherKey, &enable_launcher_));
 
+  ExtensionService* service =
+    extensions::ExtensionSystem::Get(profile_)->extension_service();
+  if (service->GetInstalledExtension(id_) ||
+      !g_pending_installs.Get().InsertInstall(profile_, id_)) {
+    SetResultCode(ALREADY_INSTALLED);
+    error_ = kAlreadyInstalledError;
+    return false;
+  }
+
   net::URLRequestContextGetter* context_getter = NULL;
   if (!icon_url.is_empty())
     context_getter = profile()->GetRequestContext();
 
   scoped_refptr<WebstoreInstallHelper> helper = new WebstoreInstallHelper(
       this, id_, manifest_, icon_data_, icon_url, context_getter);
 
   // The helper will call us back via OnWebstoreParseSuccess or
   // OnWebstoreParseFailure.
   helper->Start();
@@ skipping 29 matching lines @@
       break;
     case PERMISSION_DENIED:
       SetResult(Value::CreateStringValue("permission_denied"));
       break;
     case INVALID_ICON_URL:
       SetResult(Value::CreateStringValue("invalid_icon_url"));
       break;
     case SIGNIN_FAILED:
       SetResult(Value::CreateStringValue("signin_failed"));
       break;
+    case ALREADY_INSTALLED:
+      SetResult(Value::CreateStringValue("already_installed"));
+      break;
     default:
       CHECK(false);
   }
 }
 
 void BeginInstallWithManifestFunction::OnWebstoreParseSuccess(
     const std::string& id,
     const SkBitmap& icon,
     DictionaryValue* parsed_manifest) {
   CHECK_EQ(id_, id);
@@ skipping 42 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(profile_, id);
   SendResponse(false);
 
   // Matches the AddRef in RunImpl().
   Release();
 }
 
 void BeginInstallWithManifestFunction::GaiaCredentialsValid() {}
 
 void BeginInstallWithManifestFunction::SigninFailed(
     const GoogleServiceAuthError& error) {
   signin_tracker_.reset();
 
   SetResultCode(SIGNIN_FAILED);
   error_ = error.ToString();
+  g_pending_installs.Get().EraseInstall(profile_, id_);
   SendResponse(false);
 
   // Matches the AddRef in RunImpl().
   Release();
 }
 
 void BeginInstallWithManifestFunction::SigninSuccess() {
   signin_tracker_.reset();
 
   SigninCompletedOrNotNeeded();
@@ skipping 33 matching lines @@
   ExtensionService::RecordPermissionMessagesHistogram(
       dummy_extension_, "Extensions.Permissions_WebStoreInstall");
 
   // Matches the AddRef in RunImpl().
   Release();
 }
 
 void BeginInstallWithManifestFunction::InstallUIAbort(bool user_initiated) {
   error_ = kUserCancelledError;
   SetResultCode(USER_CANCELLED);
+  g_pending_installs.Get().EraseInstall(profile_, 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_WebStoreInstallCancel" :
       "Extensions.Permissions_WebStoreInstallAbort";
   ExtensionService::RecordPermissionMessagesHistogram(
       dummy_extension_, histogram_name.c_str());
@@ skipping 77 matching lines @@
       id, approval_.Pass(), WebstoreInstaller::FLAG_NONE);
   installer->Start();
 }
 
 void CompleteInstallFunction::OnExtensionInstallSuccess(
     const std::string& id) {
   if (test_webstore_installer_delegate)
     test_webstore_installer_delegate->OnExtensionInstallSuccess(id);
 
   LOG(INFO) << "Install success, sending response";
+  g_pending_installs.Get().EraseInstall(profile_, id);
   SendResponse(true);
 
   // Matches the AddRef in RunImpl().
   Release();
 }
 
 void CompleteInstallFunction::OnExtensionInstallFailure(
     const std::string& id,
     const std::string& error,
     WebstoreInstaller::FailureReason reason) {
   extensions::InstallTracker* tracker =
       extensions::InstallTrackerFactory::GetForProfile(profile());
   tracker->OnInstallFailure(id);
   if (test_webstore_installer_delegate) {
     test_webstore_installer_delegate->OnExtensionInstallFailure(
         id, error, reason);
   }
 
   error_ = error;
   LOG(INFO) << "Install failed, sending response";
+  g_pending_installs.Get().EraseInstall(profile_, id);
   SendResponse(false);
 
   // Matches the AddRef in RunImpl().
   Release();
 }
 
 void CompleteInstallFunction::OnExtensionDownloadProgress(
     const std::string& id,
     content::DownloadItem* item) {
   extensions::InstallTracker* tracker =
@@ skipping 63 matching lines @@
       &GetIsLauncherEnabledFunction::OnIsLauncherCheckCompleted, this));
   return true;
 }
 
 void GetIsLauncherEnabledFunction::OnIsLauncherCheckCompleted(bool is_enabled) {
   SetResult(Value::CreateBooleanValue(is_enabled));
   SendResponse(true);
 }
 
 }  // namespace extensions