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 183 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,
+    bool withheld) {

[gpdavis, 2014/08/29 01:12:16]

Figured I'd add a parameter to these two methods, but I can split em up into
SetWithheldPermissions, etc, if that's preferred.

+  if (withheld)
+    withheld_permissions_ = permissions;
+  else
+    permissions_ = permissions;
 }
 
 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,
+    bool withheld) {
+  if (withheld) {
+    withheld_details_ = details;
+    is_showing_details_for_withheld_permissions_.clear();
+    for (size_t i = 0; i < details.size(); ++i)
+      is_showing_details_for_withheld_permissions_.push_back(false);
+  } else {
+    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);
+  }
 }
 
 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;
       break;
+    case WITHHELD_PERMISSIONS_DETAILS:

[gpdavis, 2014/08/29 01:12:16]

This is necessary for the cocoa implementation, which will need to be updated as
well.

+      is_showing_details_for_withheld_permissions_[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,
     double average_rating,
@@ skipping 42 matching lines @@
       resource_id = IDS_EXTENSION_EXTERNAL_INSTALL_PROMPT_HEADING_THEME;
     else
       resource_id = IDS_EXTENSION_EXTERNAL_INSTALL_PROMPT_HEADING_EXTENSION;
     return l10n_util::GetStringUTF16(resource_id);
   } else {
     return l10n_util::GetStringFUTF16(
         kHeadingIds[type_], base::UTF8ToUTF16(extension_->name()));
   }
 }
 
+base::string16 ExtensionInstallPrompt::Prompt::GetWithheldHeading() const {
+  return l10n_util::GetStringUTF16(IDS_EXTENSION_PROMPT_WITHHELD);
+}
+
 int ExtensionInstallPrompt::Prompt::GetDialogButtons() const {
   if (type_ == POST_INSTALL_PERMISSIONS_PROMPT &&
       ShouldDisplayRevokeFilesButton()) {
     return kButtons[type_] | ui::DIALOG_BUTTON_OK;
   }
 
   return kButtons[type_];
 }
 
 bool ExtensionInstallPrompt::Prompt::ShouldShowExplanationText() const {
@@ skipping 122 matching lines @@
   CHECK_LT(index, permissions_.size());
   return permissions_[index];
 }
 
 base::string16 ExtensionInstallPrompt::Prompt::GetPermissionsDetails(
     size_t index) const {
   CHECK_LT(index, details_.size());
   return details_[index];
 }
 
+size_t ExtensionInstallPrompt::Prompt::GetWithheldPermissionCount() const {
+  return withheld_permissions_.size();
+}
+
+size_t ExtensionInstallPrompt::Prompt::GetWithheldPermissionsDetailsCount()
+    const {
+  return withheld_details_.size();
+}
+
+base::string16 ExtensionInstallPrompt::Prompt::GetWithheldPermission(
+    size_t index) const {
+  CHECK_LT(index, withheld_permissions_.size());
+  return withheld_permissions_[index];
+}
+
+base::string16 ExtensionInstallPrompt::Prompt::GetWithheldPermissionsDetails(
+    size_t index) const {
+  CHECK_LT(index, withheld_details_.size());
+  return withheld_details_[index];
+}
+
 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];
+    case WITHHELD_PERMISSIONS_DETAILS:
+      CHECK_LT(index, is_showing_details_for_withheld_permissions_.size());
+      return is_showing_details_for_withheld_permissions_[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 278 matching lines @@
     prompt_->set_experiment(ExtensionInstallPromptExperiment::ControlGroup());
 
   if (permissions_.get() &&
       (!extension_ ||
        !extensions::PermissionsData::ShouldSkipPermissionWarnings(
            extension_->id()))) {
     Manifest::Type type =
         extension_ ? extension_->GetType() : Manifest::TYPE_UNKNOWN;
     const extensions::PermissionMessageProvider* message_provider =
         extensions::PermissionMessageProvider::Get();
+
+    // Initialize permissions so that withheld permissions don't end up in the
+    // install prompt.
+    if (extension_) {
+      extensions::PermissionsUpdater(install_ui_->profile())
+          .InitializePermissions(
+              extension_, extensions::PermissionsUpdater::INIT_FLAG_TRANSIENT);
+      permissions_ = extension_->permissions_data()->active_permissions();
+    }
     prompt_->SetPermissions(
-        message_provider->GetWarningMessages(permissions_.get(), type));
+        message_provider->GetWarningMessages(permissions_.get(), type),
+        false);  // withheld
     prompt_->SetPermissionsDetails(
-        message_provider->GetWarningMessagesDetails(permissions_.get(), type));
+        message_provider->GetWarningMessagesDetails(permissions_.get(), type),
+        false);  // withheld
+
+    scoped_refptr<const extensions::PermissionSet> withheld =
+        extension_->permissions_data()->withheld_permissions();
+    if (!withheld->IsEmpty()) {
+      prompt_->SetPermissions(
+          message_provider->GetWarningMessages(withheld.get(), type),
+          true);  // withheld
+      prompt_->SetPermissionsDetails(
+          message_provider->GetWarningMessagesDetails(withheld.get(), type),
+          true);  // withheld
+    }
   }
 
   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_);
 }