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 507 matching lines @@
 }
 
 ExtensionInstallPrompt::~ExtensionInstallPrompt() {
 }
 
 void ExtensionInstallPrompt::ConfirmBundleInstall(
     extensions::BundleInstaller* bundle,
     const PermissionSet* permissions) {
   DCHECK(ui_loop_ == base::MessageLoop::current());
   bundle_ = bundle;
+  // |bundle|'s extensions have already had their permissions initialized at
+  // this point, so withheld permissions will not show up in the prompt.
   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;
+  // Initialize permissions so that withheld permissions don't end up in the
+  // install prompt.
+  extensions::PermissionsUpdater(install_ui_->profile()).InitializePermissions(
+      extension_);

[not at google - send to devlin, 2014/08/28 03:17:32]

A weirdness here is that even though this is a dummy extension we're still going
to prefs to look for it (see the implementation of InitializePermissions). It
works because that ends up reading NULL for the permissions and we end up using
permissions_data()->active_permissions(), which is correct, but still. Weird.
And what if InitializePermissions one day starts writing stuff to prefs?

We need a "no prefs" version of InitializePermissions :\ which implies a static
InitializePermissions-type method ... which is yuck.

Ping this stuff to me tomorrow. I can't think of a particularly nice way of
doing it right now.

[gpdavis, 2014/08/28 17:41:48]

Ping :)

What if we just add a flag to InitializePermissions?  Something like
is_dummy_extension, and if it's true, we don't access prefs and we can add a
comment that indicates that dummy extensions shouldn't be looked for in prefs? 
InitializePermissions isn't called all that many times, so this shouldn't create
too much of an impact elsewhere.

[not at google - send to devlin, 2014/08/28 18:28:02]

Yes! That's the best solution I came up with as well. Modulo a different syntax.
Let's use flags, like:

class PermissionsUpdater {
  enum InitFlag {
    INIT_FLAG_NONE = 0,
    INIT_FLAG_TRANSIENT = 1<<1,
  };

  void InitializePermissions(extension) {
    InitializePermissions(extension, INIT_FLAG_NONE);
  }

  void InitializePermissions(extension, flag) {
    if (flag & INIT_FLAG_TRANSIENT)
      ...  // don't console preferences about |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;
+  // Initialize permissions so that withheld permissions don't end up in the
+  // install prompt.
+  extensions::PermissionsUpdater(install_ui_->profile()).InitializePermissions(
+      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
@@ skipping 147 matching lines @@
       (!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));

[not at google - send to devlin, 2014/08/28 03:17:32]

Around here should be the place that you pull out the permission warnings, not
up top. There are a lot of cases you're missing there. Having it here would pick
those up.

[gpdavis, 2014/08/28 17:41:48]

For some reason I felt like I needed to initialize them before permissions_ was
set, but now I'm realizing that it's just a pointer, so it doesn't matter, as
long as it's initialized before SetPermissions.  Oops.

So the only missing case here is the bundle, correct?  And we can just handle
that over in the bundle installer.

   }
 
   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_);
 }