Make sideloaded (externally installed) extensions display webstore info

chrome/browser/extensions/external_install_ui.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/external_install_ui.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/chrome_notification_types.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/extension_uninstall_dialog.h"
+#include "chrome/browser/extensions/webstore_data_fetcher.h"
+#include "chrome/browser/extensions/webstore_data_fetcher_delegate.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/global_error/global_error.h"
 #include "chrome/browser/ui/global_error/global_error_service.h"
 #include "chrome/browser/ui/global_error/global_error_service_factory.h"
 #include "chrome/browser/ui/host_desktop.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/manifest_url_handler.h"
 #include "content/public/browser/notification_details.h"
@@ skipping 17 matching lines @@
 bool UseBubbleInstall(const Extension* extension, bool is_new_profile) {
   return ManifestURL::UpdatesFromGallery(extension) && !is_new_profile;
 }
 
 }  // namespace
 
 static const int kMenuCommandId = IDC_EXTERNAL_EXTENSION_ALERT;
 
 class ExternalInstallGlobalError;
 
-// TODO(mpcomplete): Get rid of the refcounting on this class, or document
-// why it's necessary. Will do after refactoring to merge back with
-// ExtensionDisabledDialogDelegate.
+// This class is refcounted to stay alive while we try and pull webstore data.
 class ExternalInstallDialogDelegate
     : public ExtensionInstallPrompt::Delegate,
+      public WebstoreDataFetcherDelegate,
       public base::RefCountedThreadSafe<ExternalInstallDialogDelegate> {
  public:
   ExternalInstallDialogDelegate(Browser* browser,
                                 ExtensionService* service,
                                 const Extension* extension,
                                 bool use_global_error);
 
   Browser* browser() { return browser_; }
 
  private:
   friend class base::RefCountedThreadSafe<ExternalInstallDialogDelegate>;
   friend class ExternalInstallGlobalError;
 
   virtual ~ExternalInstallDialogDelegate();
 
   // ExtensionInstallPrompt::Delegate:
   virtual void InstallUIProceed() OVERRIDE;
   virtual void InstallUIAbort(bool user_initiated) OVERRIDE;
 
+  // WebstoreDataFetcherDelegate:
+  virtual void OnWebstoreRequestFailure() OVERRIDE;
+  virtual void OnWebstoreResponseParseSuccess(
+      scoped_ptr<base::DictionaryValue> webstore_data) OVERRIDE;
+  virtual void OnWebstoreResponseParseFailure(
+      const std::string& error) OVERRIDE;
+
+  // Show the install dialog to the user.
+  void ShowInstallUI();
+
   // The UI for showing the install dialog when enabling.
   scoped_ptr<ExtensionInstallPrompt> install_ui_;
+  scoped_ptr<ExtensionInstallPrompt::Prompt> prompt_;
 
   Browser* browser_;
   base::WeakPtr<ExtensionService> service_weak_;
-  const std::string extension_id_;
+  scoped_ptr<WebstoreDataFetcher> webstore_data_fetcher_;
+  std::string extension_id_;
+  bool use_global_error_;
+
+  DISALLOW_COPY_AND_ASSIGN(ExternalInstallDialogDelegate);
 };
 
 // Only shows a menu item, no bubble. Clicking the menu item shows
 // an external install dialog.
 class ExternalInstallMenuAlert : public GlobalErrorWithStandardBubble,
                                  public content::NotificationObserver {
  public:
   ExternalInstallMenuAlert(ExtensionService* service,
                            const Extension* extension);
   virtual ~ExternalInstallMenuAlert();
 
-  const Extension* extension() const { return extension_; }
-
   // GlobalError implementation.
   virtual Severity GetSeverity() OVERRIDE;
   virtual bool HasMenuItem() OVERRIDE;
   virtual int MenuItemCommandID() OVERRIDE;
   virtual base::string16 MenuItemLabel() OVERRIDE;
   virtual void ExecuteMenuItem(Browser* browser) OVERRIDE;
   virtual bool HasBubbleView() OVERRIDE;
   virtual base::string16 GetBubbleViewTitle() OVERRIDE;
   virtual std::vector<base::string16> GetBubbleViewMessages() OVERRIDE;
   virtual base::string16 GetBubbleViewAcceptButtonLabel() OVERRIDE;
   virtual base::string16 GetBubbleViewCancelButtonLabel() OVERRIDE;
   virtual void OnBubbleViewDidClose(Browser* browser) OVERRIDE;
   virtual void BubbleViewAcceptButtonPressed(Browser* browser) OVERRIDE;
   virtual void BubbleViewCancelButtonPressed(Browser* browser) OVERRIDE;
 
   // content::NotificationObserver implementation.
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
  protected:
   ExtensionService* service_;
   const Extension* extension_;
   content::NotificationRegistrar registrar_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ExternalInstallMenuAlert);
 };
 
 // Shows a menu item and a global error bubble, replacing the install dialog.
 class ExternalInstallGlobalError : public ExternalInstallMenuAlert {
  public:
   ExternalInstallGlobalError(ExtensionService* service,
                              const Extension* extension,
                              ExternalInstallDialogDelegate* delegate,
                              const ExtensionInstallPrompt::Prompt& prompt);
   virtual ~ExternalInstallGlobalError();
 
   virtual void ExecuteMenuItem(Browser* browser) OVERRIDE;
   virtual bool HasBubbleView() OVERRIDE;
   virtual gfx::Image GetBubbleViewIcon() OVERRIDE;
   virtual base::string16 GetBubbleViewTitle() OVERRIDE;
   virtual std::vector<base::string16> GetBubbleViewMessages() OVERRIDE;
   virtual base::string16 GetBubbleViewAcceptButtonLabel() OVERRIDE;
   virtual base::string16 GetBubbleViewCancelButtonLabel() OVERRIDE;
   virtual void OnBubbleViewDidClose(Browser* browser) OVERRIDE;
   virtual void BubbleViewAcceptButtonPressed(Browser* browser) OVERRIDE;
   virtual void BubbleViewCancelButtonPressed(Browser* browser) OVERRIDE;
 
  protected:
   // Ref-counted, but needs to be disposed of if we are dismissed without
   // having been clicked (perhaps because the user enabled the extension
   // manually).
   ExternalInstallDialogDelegate* delegate_;
   const ExtensionInstallPrompt::Prompt* prompt_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ExternalInstallGlobalError);
 };
 
 static void CreateExternalInstallGlobalError(
     base::WeakPtr<ExtensionService> service,
     const std::string& extension_id,
     const ExtensionInstallPrompt::ShowParams& show_params,
     ExtensionInstallPrompt::Delegate* prompt_delegate,
     const ExtensionInstallPrompt::Prompt& prompt) {
   if (!service.get())
     return;
@@ skipping 25 matching lines @@
 
 // ExternalInstallDialogDelegate --------------------------------------------
 
 ExternalInstallDialogDelegate::ExternalInstallDialogDelegate(
     Browser* browser,
     ExtensionService* service,
     const Extension* extension,
     bool use_global_error)
     : browser_(browser),
       service_weak_(service->AsWeakPtr()),
-      extension_id_(extension->id()) {
+      extension_id_(extension->id()),
+      use_global_error_(use_global_error) {
   AddRef();  // Balanced in Proceed or Abort.
 
+  prompt_.reset(new ExtensionInstallPrompt::Prompt(
+      ExtensionInstallPrompt::EXTERNAL_INSTALL_PROMPT));
+
+  // If we don't have a browser, we can't go to the webstore to fetch data.
+  // This should only happen in tests.
+  if (!browser) {
+    ShowInstallUI();
+    return;
+  }
+
+  webstore_data_fetcher_.reset(new WebstoreDataFetcher(
+      this,
+      browser->profile()->GetRequestContext(),
+      GURL::EmptyGURL(),
+      extension->id()));
+  webstore_data_fetcher_->Start();
+}
+
+void ExternalInstallDialogDelegate::OnWebstoreRequestFailure() {
+  ShowInstallUI();
+}
+
+void ExternalInstallDialogDelegate::OnWebstoreResponseParseSuccess(
+    scoped_ptr<base::DictionaryValue> webstore_data) {
+  std::string localized_user_count;
+  double average_rating;
+  int rating_count;
+  if (!webstore_data->GetString(kUsersKey, &localized_user_count) ||
+      !webstore_data->GetDouble(kAverageRatingKey, &average_rating) ||
+      !webstore_data->GetInteger(kRatingCountKey, &rating_count)) {
+    // If we don't get a valid webstore response, short circuit, and continue
+    // to show a prompt without webstore data.
+    ShowInstallUI();
+    return;
+  }
+
+  bool show_user_count = true;
+  webstore_data->GetBoolean(kShowUserCountKey, &show_user_count);
+
+  prompt_->SetWebstoreData(localized_user_count,
+                           show_user_count,
+                           average_rating,
+                           rating_count);
+
+  ShowInstallUI();
+}
+
+void ExternalInstallDialogDelegate::OnWebstoreResponseParseFailure(
+    const std::string& error) {
+  ShowInstallUI();
+}
+
+void ExternalInstallDialogDelegate::ShowInstallUI() {
+  const Extension* extension = NULL;
+  if (!service_weak_.get() ||
+      !(extension = service_weak_->GetInstalledExtension(extension_id_))) {
+    return;
+  }
   install_ui_.reset(
-      ExtensionInstallUI::CreateInstallPromptWithBrowser(browser));
+      ExtensionInstallUI::CreateInstallPromptWithBrowser(browser_));
 
   const ExtensionInstallPrompt::ShowDialogCallback callback =
-      use_global_error ?
-      base::Bind(&CreateExternalInstallGlobalError,
-                 service_weak_, extension_id_) :
-      ExtensionInstallPrompt::GetDefaultShowDialogCallback();
-  install_ui_->ConfirmExternalInstall(this, extension, callback);
+      use_global_error_ ?
+          base::Bind(&CreateExternalInstallGlobalError,
+                     service_weak_,
+                     extension_id_) :
+          ExtensionInstallPrompt::GetDefaultShowDialogCallback();
+
+  install_ui_->ConfirmExternalInstall(this, extension, callback, *prompt_);
 }
 
 ExternalInstallDialogDelegate::~ExternalInstallDialogDelegate() {
 }
 
 void ExternalInstallDialogDelegate::InstallUIProceed() {
-  if (!service_weak_.get())
+  const Extension* extension = NULL;
+  if (!service_weak_.get() ||
+      !(extension = service_weak_->GetInstalledExtension(extension_id_))) {
     return;
-  const Extension* extension =
-      service_weak_->GetInstalledExtension(extension_id_);
-  if (!extension)
-    return;
+  }
   service_weak_->GrantPermissionsAndEnableExtension(extension);
   Release();
 }
 
 void ExternalInstallDialogDelegate::InstallUIAbort(bool user_initiated) {
-  if (!service_weak_.get())
+  const Extension* extension = NULL;
+  if (!service_weak_.get() ||
+      !(extension = service_weak_->GetInstalledExtension(extension_id_))) {
     return;
-  const Extension* extension =
-      service_weak_->GetInstalledExtension(extension_id_);
-  if (!extension)
-    return;
+  }
   service_weak_->UninstallExtension(extension_id_, false, NULL);
   Release();
 }
 
 // ExternalInstallMenuAlert -------------------------------------------------
 
 ExternalInstallMenuAlert::ExternalInstallMenuAlert(
     ExtensionService* service,
     const Extension* extension)
     : service_(service),
@@ skipping 210 matching lines @@
 
 bool HasExternalInstallBubble(ExtensionService* service) {
   GlobalErrorService* error_service =
       GlobalErrorServiceFactory::GetForProfile(service->profile());
   GlobalError* error = error_service->GetGlobalErrorByMenuItemCommandID(
       kMenuCommandId);
   return error && error->HasBubbleView();
 }
 
 }  // namespace extensions