Update extension install prompt to reflect withheld permissions

chrome/browser/extensions/extension_install_prompt.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/extension_install_prompt.h"
 
 #include <map>
 
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "base/prefs/pref_service.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 "chrome/browser/extensions/bundle_installer.h"
 #include "chrome/browser/extensions/extension_install_ui.h"
 #include "chrome/browser/extensions/extension_util.h"
+#include "chrome/browser/extensions/permissions_updater.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/grit/chromium_strings.h"
 #include "chrome/grit/generated_resources.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_util.h"
@@ skipping 136 matching lines @@
 
 gfx::NativeWindow NativeWindowForWebContents(content::WebContents* contents) {
   if (!contents)
     return NULL;
 
   return contents->GetTopLevelNativeWindow();
 }
 
 }  // namespace
 
+ExtensionInstallPrompt::Prompt::InstallPromptPermissions::
+    InstallPromptPermissions() {
+}
+ExtensionInstallPrompt::Prompt::InstallPromptPermissions::
+    ~InstallPromptPermissions() {
+}
+
 // static
 ExtensionInstallPrompt::AutoConfirmForTests
 ExtensionInstallPrompt::g_auto_confirm_for_tests = ExtensionInstallPrompt::NONE;
 
 // This should match the PromptType enum.
 std::string ExtensionInstallPrompt::PromptTypeToString(PromptType type) {
   switch (type) {
     case ExtensionInstallPrompt::INSTALL_PROMPT:
       return "INSTALL_PROMPT";
     case ExtensionInstallPrompt::INLINE_INSTALL_PROMPT:
@@ skipping 27 matching lines @@
       average_rating_(0.0),
       rating_count_(0),
       show_user_count_(false),
       has_webstore_data_(false) {
 }
 
 ExtensionInstallPrompt::Prompt::~Prompt() {
 }
 
 void ExtensionInstallPrompt::Prompt::SetPermissions(
-    const std::vector<base::string16>& permissions) {
-  permissions_ = permissions;
+    const std::vector<base::string16>& permissions,
+    PermissionsType permissions_type) {
+  switch (permissions_type) {
+    case REGULAR_PERMISSIONS:
+      prompt_permissions_.permissions = permissions;
+      break;
+    case WITHHELD_PERMISSIONS:
+      withheld_prompt_permissions_.permissions = permissions;
+      break;
+    case ALL_PERMISSIONS:
+      NOTREACHED();
+      break;
+  }
 }
 
 void ExtensionInstallPrompt::Prompt::SetPermissionsDetails(
-    const std::vector<base::string16>& details) {
-  details_ = details;
-  is_showing_details_for_permissions_.clear();
-  for (size_t i = 0; i < details.size(); ++i)
-    is_showing_details_for_permissions_.push_back(false);
+    const std::vector<base::string16>& details,
+    PermissionsType permissions_type) {
+  switch (permissions_type) {

[Devlin, 2014/09/08 16:09:22]

Two improvements here:
- reduce duplicate code by setting a temp to the permissions to use.
- reduce work and code by using vector::insert()

Something like:
DCHECK_NE(ALL_PERMISSIONS, permissions_type);
InstallPromptPermissions& permissions =
    permissions_type == REGULAR_PERMISSIONS ? prompt_permissions_ :
                                              withheld_prompt_permissions_;
permissions.details = details;
permissions.is_showing_details.clear();
permissions.is_showing_details.insert(
    permissions.is_showing_details.begin(), permissions.details.size(), false);

[gpdavis, 2014/09/08 20:07:05]

Done.

+    case REGULAR_PERMISSIONS:
+      prompt_permissions_.details = details;
+      prompt_permissions_.is_showing_details.clear();
+      for (size_t i = 0; i < details.size(); ++i)
+        prompt_permissions_.is_showing_details.push_back(false);
+      break;
+    case WITHHELD_PERMISSIONS:
+      withheld_prompt_permissions_.details = details;
+      withheld_prompt_permissions_.is_showing_details.clear();
+      for (size_t i = 0; i < details.size(); ++i)
+        withheld_prompt_permissions_.is_showing_details.push_back(false);
+      break;
+    case ALL_PERMISSIONS:
+      NOTREACHED();
+      break;
+  }
 }
 
 void ExtensionInstallPrompt::Prompt::SetIsShowingDetails(
     DetailsType type,
     size_t index,
     bool is_showing_details) {
   switch (type) {
     case PERMISSIONS_DETAILS:
-      is_showing_details_for_permissions_[index] = is_showing_details;
+      prompt_permissions_.is_showing_details[index] = is_showing_details;
+      break;
+    case WITHHELD_PERMISSIONS_DETAILS:
+      withheld_prompt_permissions_.is_showing_details[index] =
+          is_showing_details;
       break;
     case RETAINED_FILES_DETAILS:
       is_showing_details_for_retained_files_ = is_showing_details;
       break;
   }
 }
 
 void ExtensionInstallPrompt::Prompt::SetWebstoreData(
     const std::string& localized_user_count,
     bool show_user_count,
@@ skipping 96 matching lines @@
   return kAbortButtonIds[type_] > 0;
 }
 
 base::string16 ExtensionInstallPrompt::Prompt::GetAbortButtonLabel() const {
   CHECK(HasAbortButtonLabel());
   if (ShouldShowExplanationText())
     return experiment_->GetCancelButtonText();
   return l10n_util::GetStringUTF16(kAbortButtonIds[type_]);
 }
 
-base::string16 ExtensionInstallPrompt::Prompt::GetPermissionsHeading() const {
-  return l10n_util::GetStringUTF16(kPermissionsHeaderIds[type_]);
+base::string16 ExtensionInstallPrompt::Prompt::GetPermissionsHeading(
+    PermissionsType permissions_type) const {
+  switch (permissions_type) {
+    case REGULAR_PERMISSIONS:
+      return l10n_util::GetStringUTF16(kPermissionsHeaderIds[type_]);
+    case WITHHELD_PERMISSIONS:
+      return l10n_util::GetStringUTF16(IDS_EXTENSION_PROMPT_WITHHELD);
+    case ALL_PERMISSIONS:
+      NOTREACHED();
+      return base::string16();
+  }
 }
 
 base::string16 ExtensionInstallPrompt::Prompt::GetRetainedFilesHeading() const {
   const int kRetainedFilesMessageIDs[6] = {
       IDS_EXTENSION_PROMPT_RETAINED_FILES_DEFAULT,
       IDS_EXTENSION_PROMPT_RETAINED_FILE_SINGULAR,
       IDS_EXTENSION_PROMPT_RETAINED_FILES_ZERO,
       IDS_EXTENSION_PROMPT_RETAINED_FILES_TWO,
       IDS_EXTENSION_PROMPT_RETAINED_FILES_FEW,
       IDS_EXTENSION_PROMPT_RETAINED_FILES_MANY,
   };
   std::vector<int> message_ids;
   for (size_t i = 0; i < arraysize(kRetainedFilesMessageIDs); i++) {
     message_ids.push_back(kRetainedFilesMessageIDs[i]);
   }
   return l10n_util::GetPluralStringFUTF16(message_ids, GetRetainedFileCount());
 }
 
 bool ExtensionInstallPrompt::Prompt::ShouldShowPermissions() const {
-  return GetPermissionCount() > 0 || type_ == POST_INSTALL_PERMISSIONS_PROMPT;
+  return GetPermissionCount(REGULAR_PERMISSIONS) > 0 ||
+         GetPermissionCount(WITHHELD_PERMISSIONS) > 0 ||
+         type_ == POST_INSTALL_PERMISSIONS_PROMPT;
 }
 
 void ExtensionInstallPrompt::Prompt::AppendRatingStars(
     StarAppender appender, void* data) const {
   CHECK(appender);
   CHECK(type_ == INLINE_INSTALL_PROMPT || type_ == EXTERNAL_INSTALL_PROMPT);
   int rating_integer = floor(average_rating_);
   double rating_fractional = average_rating_ - rating_integer;
 
   if (rating_fractional > 0.66) {
@@ skipping 27 matching lines @@
 base::string16 ExtensionInstallPrompt::Prompt::GetUserCount() const {
   CHECK(type_ == INLINE_INSTALL_PROMPT || type_ == EXTERNAL_INSTALL_PROMPT);
 
   if (show_user_count_) {
     return l10n_util::GetStringFUTF16(IDS_EXTENSION_USER_COUNT,
                                       base::UTF8ToUTF16(localized_user_count_));
   }
   return base::string16();
 }
 
-size_t ExtensionInstallPrompt::Prompt::GetPermissionCount() const {
-  return permissions_.size();
+size_t ExtensionInstallPrompt::Prompt::GetPermissionCount(
+    PermissionsType permissions_type) const {
+  switch (permissions_type) {
+    case REGULAR_PERMISSIONS:
+      return prompt_permissions_.permissions.size();
+    case WITHHELD_PERMISSIONS:
+      return withheld_prompt_permissions_.permissions.size();
+    case ALL_PERMISSIONS:
+      return prompt_permissions_.permissions.size() +
+             withheld_prompt_permissions_.permissions.size();
+  }
 }
 
-size_t ExtensionInstallPrompt::Prompt::GetPermissionsDetailsCount() const {
-  return details_.size();
+size_t ExtensionInstallPrompt::Prompt::GetPermissionsDetailsCount(
+    PermissionsType permissions_type) const {
+  switch (permissions_type) {
+    case REGULAR_PERMISSIONS:
+      return prompt_permissions_.details.size();
+    case WITHHELD_PERMISSIONS:
+      return withheld_prompt_permissions_.details.size();
+    case ALL_PERMISSIONS:
+      return prompt_permissions_.details.size() +
+             withheld_prompt_permissions_.details.size();
+  }
 }
 
-base::string16 ExtensionInstallPrompt::Prompt::GetPermission(size_t index)
-    const {
-  CHECK_LT(index, permissions_.size());
-  return permissions_[index];
+base::string16 ExtensionInstallPrompt::Prompt::GetPermission(
+    size_t index,
+    PermissionsType permissions_type) const {
+  switch (permissions_type) {
+    case REGULAR_PERMISSIONS:
+      CHECK_LT(index, prompt_permissions_.permissions.size());
+      return prompt_permissions_.permissions[index];
+    case WITHHELD_PERMISSIONS:
+      CHECK_LT(index, withheld_prompt_permissions_.permissions.size());
+      return withheld_prompt_permissions_.permissions[index];
+    case ALL_PERMISSIONS:
+      NOTREACHED();

[Devlin, 2014/09/08 16:09:22]

Actually, let's even make a

InstallPromptPermissions&
GetPermissionsToUse(PermissionsType permissions_type) {
  DCHECK_NE(ALL_PERMISSIONS, permissions_type);
  return permissions_type == REGULAR_PERMISSIONS ? prompt_permissions_ :
                                                   withheld_prompt_permissions_;
}

Then we use that anywhere we have this pattern (specifically with the
NOTREACHED()), and this method becomes:
{
const InstallPromptPermissions& permissions =
GetPermissionsToUse(permissions_type);
CHECK_LT(index, permissions.size());
return permissions[index];
}

[gpdavis, 2014/09/08 20:07:05]

I like this idea, but we've got a const problem.  The setter methods need a
non-const reference, but the getter methods are const.  I'll just inline it,
unless you'd prefer it another way.

[Devlin, 2014/09/09 15:53:21]

Hmm... Lame.  I think I might opt for still making the helper method, and just
making a const and non-const version.  It makes the code in these methods a lot
easier to read, IMO.  How's the line count vary?

[gpdavis, 2014/09/09 17:32:41]

The file is six lines longer with the two helper methods.  I agree that it makes
the code easier to read, but it can only effectively be used in
Get/SetPermissions and Get/SetPermissionsDetails.  Your call on whether it's
worth it.

[Devlin, 2014/09/09 17:46:22]

I say go for it.  Readability wins out.

[gpdavis, 2014/09/09 20:28:15]

Sounds good!

+      return base::string16();
+  }
 }
 
 base::string16 ExtensionInstallPrompt::Prompt::GetPermissionsDetails(
-    size_t index) const {
-  CHECK_LT(index, details_.size());
-  return details_[index];
+    size_t index,
+    PermissionsType permissions_type) const {
+  switch (permissions_type) {
+    case REGULAR_PERMISSIONS:
+      CHECK_LT(index, prompt_permissions_.details.size());
+      return prompt_permissions_.details[index];
+    case WITHHELD_PERMISSIONS:
+      CHECK_LT(index, withheld_prompt_permissions_.details.size());
+      return withheld_prompt_permissions_.details[index];
+    case ALL_PERMISSIONS:
+      NOTREACHED();
+      return base::string16();
+  }
 }
 
 bool ExtensionInstallPrompt::Prompt::GetIsShowingDetails(
     DetailsType type, size_t index) const {
   switch (type) {
     case PERMISSIONS_DETAILS:
-      CHECK_LT(index, is_showing_details_for_permissions_.size());
-      return is_showing_details_for_permissions_[index];
+      CHECK_LT(index, prompt_permissions_.is_showing_details.size());
+      return prompt_permissions_.is_showing_details[index];
+    case WITHHELD_PERMISSIONS_DETAILS:
+      CHECK_LT(index, withheld_prompt_permissions_.is_showing_details.size());
+      return withheld_prompt_permissions_.is_showing_details[index];
     case RETAINED_FILES_DETAILS:
       return is_showing_details_for_retained_files_;
   }
   return false;
 }
 
 size_t ExtensionInstallPrompt::Prompt::GetRetainedFileCount() const {
   return retained_files_.size();
 }
 
@@ skipping 74 matching lines @@
 }
 
 ExtensionInstallPrompt::~ExtensionInstallPrompt() {
 }
 
 void ExtensionInstallPrompt::ConfirmBundleInstall(
     extensions::BundleInstaller* bundle,
     const PermissionSet* permissions) {
   DCHECK(ui_loop_ == base::MessageLoop::current());
   bundle_ = bundle;
-  permissions_ = permissions;
+  custom_permissions_ = permissions;
   delegate_ = bundle;
   prompt_ = new Prompt(BUNDLE_INSTALL_PROMPT);
 
   ShowConfirmation();
 }
 
 void ExtensionInstallPrompt::ConfirmStandaloneInstall(
     Delegate* delegate,
     const Extension* extension,
     SkBitmap* icon,
     scoped_refptr<Prompt> prompt) {
   DCHECK(ui_loop_ == base::MessageLoop::current());
   extension_ = extension;
-  permissions_ = extension->permissions_data()->active_permissions();
   delegate_ = delegate;
   prompt_ = prompt;
 
   SetIcon(icon);
   ShowConfirmation();
 }
 
 void ExtensionInstallPrompt::ConfirmWebstoreInstall(
     Delegate* delegate,
     const Extension* extension,
     const SkBitmap* icon,
     const ShowDialogCallback& show_dialog_callback) {
   // SetIcon requires |extension_| to be set. ConfirmInstall will setup the
   // remaining fields.
   extension_ = extension;
   SetIcon(icon);
   ConfirmInstall(delegate, extension, show_dialog_callback);
 }
 
 void ExtensionInstallPrompt::ConfirmInstall(
     Delegate* delegate,
     const Extension* extension,
     const ShowDialogCallback& show_dialog_callback) {
   DCHECK(ui_loop_ == base::MessageLoop::current());
   extension_ = extension;
-  permissions_ = extension->permissions_data()->active_permissions();
   delegate_ = delegate;
   prompt_ = new Prompt(INSTALL_PROMPT);
   show_dialog_callback_ = show_dialog_callback;
 
   // We special-case themes to not show any confirm UI. Instead they are
   // immediately installed, and then we show an infobar (see OnInstallSuccess)
   // to allow the user to revert if they don't like it.
   //
   // We don't do this in the case where off-store extension installs are
   // disabled because in that case, we don't show the dangerous download UI, so
   // we need the UI confirmation.
   if (extension->is_theme()) {
     if (extension->from_webstore() ||
         extensions::FeatureSwitch::easy_off_store_install()->IsEnabled()) {
       delegate->InstallUIProceed();
       return;
     }
   }
 
   LoadImageIfNeeded();
 }
 
 void ExtensionInstallPrompt::ConfirmReEnable(Delegate* delegate,
                                              const Extension* extension) {
   DCHECK(ui_loop_ == base::MessageLoop::current());
   extension_ = extension;
-  permissions_ = extension->permissions_data()->active_permissions();
   delegate_ = delegate;
   bool is_remote_install =
       install_ui_->profile() &&
       extensions::ExtensionPrefs::Get(install_ui_->profile())->HasDisableReason(
           extension->id(), extensions::Extension::DISABLE_REMOTE_INSTALL);
   bool is_ephemeral =
       extensions::util::IsEphemeralApp(extension->id(), install_ui_->profile());
 
   PromptType type = UNSET_PROMPT_TYPE;
   if (is_ephemeral)
     type = LAUNCH_PROMPT;
   else if (is_remote_install)
     type = REMOTE_INSTALL_PROMPT;
   else
     type = RE_ENABLE_PROMPT;
   prompt_ = new Prompt(type);
 
   LoadImageIfNeeded();
 }
 
 void ExtensionInstallPrompt::ConfirmExternalInstall(
     Delegate* delegate,
     const Extension* extension,
     const ShowDialogCallback& show_dialog_callback,
     scoped_refptr<Prompt> prompt) {
   DCHECK(ui_loop_ == base::MessageLoop::current());
   extension_ = extension;
-  permissions_ = extension->permissions_data()->active_permissions();
   delegate_ = delegate;
   prompt_ = prompt;
   show_dialog_callback_ = show_dialog_callback;
 
   LoadImageIfNeeded();
 }
 
 void ExtensionInstallPrompt::ConfirmPermissions(
     Delegate* delegate,
     const Extension* extension,
     const PermissionSet* permissions) {
   DCHECK(ui_loop_ == base::MessageLoop::current());
   extension_ = extension;
-  permissions_ = permissions;
+  custom_permissions_ = permissions;
   delegate_ = delegate;
   prompt_ = new Prompt(PERMISSIONS_PROMPT);
 
   LoadImageIfNeeded();
 }
 
 void ExtensionInstallPrompt::ReviewPermissions(
     Delegate* delegate,
     const Extension* extension,
     const std::vector<base::FilePath>& retained_file_paths) {
   DCHECK(ui_loop_ == base::MessageLoop::current());
   extension_ = extension;
-  permissions_ = extension->permissions_data()->active_permissions();
   prompt_ = new Prompt(POST_INSTALL_PERMISSIONS_PROMPT);
   prompt_->set_retained_files(retained_file_paths);
   delegate_ = delegate;
 
   LoadImageIfNeeded();
 }
 
 void ExtensionInstallPrompt::OnInstallSuccess(const Extension* extension,
                                               SkBitmap* icon) {
   extension_ = extension;
@@ skipping 53 matching lines @@
       images_list,
       base::Bind(&ExtensionInstallPrompt::OnImageLoaded, AsWeakPtr()));
 }
 
 void ExtensionInstallPrompt::ShowConfirmation() {
   if (prompt_->type() == INSTALL_PROMPT)
     prompt_->set_experiment(ExtensionInstallPromptExperiment::Find());
   else
     prompt_->set_experiment(ExtensionInstallPromptExperiment::ControlGroup());
 
-  if (permissions_.get() &&
+  scoped_refptr<const PermissionSet> permissions_to_display;
+  if (custom_permissions_.get()) {
+    permissions_to_display = custom_permissions_;
+  } else if (extension_) {
+    // Initialize permissions if they have not already been set so that
+    // withheld permissions don't end up in the install prompt.
+    extensions::PermissionsUpdater(install_ui_->profile())
+        .InitializePermissions(
+            extension_, extensions::PermissionsUpdater::INIT_FLAG_TRANSIENT);
+    permissions_to_display =
+        extension_->permissions_data()->active_permissions();
+  }
+
+  if (permissions_to_display.get() &&
       (!extension_ ||
        !extensions::PermissionsData::ShouldSkipPermissionWarnings(
            extension_->id()))) {
     Manifest::Type type =
         extension_ ? extension_->GetType() : Manifest::TYPE_UNKNOWN;
     const extensions::PermissionMessageProvider* message_provider =
         extensions::PermissionMessageProvider::Get();
-    prompt_->SetPermissions(
-        message_provider->GetWarningMessages(permissions_.get(), type));
-    prompt_->SetPermissionsDetails(
-        message_provider->GetWarningMessagesDetails(permissions_.get(), type));
+    prompt_->SetPermissions(message_provider->GetWarningMessages(
+                                permissions_to_display.get(), type),
+                            REGULAR_PERMISSIONS);
+    prompt_->SetPermissionsDetails(message_provider->GetWarningMessagesDetails(
+                                       permissions_to_display.get(), type),
+                                   REGULAR_PERMISSIONS);
+
+    scoped_refptr<const extensions::PermissionSet> withheld =
+        extension_->permissions_data()->withheld_permissions();
+    if (!withheld->IsEmpty()) {
+      prompt_->SetPermissions(
+          message_provider->GetWarningMessages(withheld.get(), type),
+          PermissionsType::WITHHELD_PERMISSIONS);
+      prompt_->SetPermissionsDetails(
+          message_provider->GetWarningMessagesDetails(withheld.get(), type),
+          PermissionsType::WITHHELD_PERMISSIONS);
+    }
   }
 
   switch (prompt_->type()) {
     case PERMISSIONS_PROMPT:
     case RE_ENABLE_PROMPT:
     case INLINE_INSTALL_PROMPT:
     case EXTERNAL_INSTALL_PROMPT:
     case INSTALL_PROMPT:
     case LAUNCH_PROMPT:
     case POST_INSTALL_PERMISSIONS_PROMPT:
@@ skipping 12 matching lines @@
   }
 
   if (AutoConfirmPrompt(delegate_))
     return;
 
   if (show_dialog_callback_.is_null())
     GetDefaultShowDialogCallback().Run(show_params_, delegate_, prompt_);
   else
     show_dialog_callback_.Run(show_params_, delegate_, prompt_);
 }