Update extension install prompt to reflect withheld permissions

chrome/browser/extensions/bundle_installer.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/bundle_installer.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/i18n/rtl.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/crx_installer.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_finder.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/grit/generated_resources.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/permissions/permission_set.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace extensions {
 
 namespace {
 
 enum AutoApproveForTest {
   DO_NOT_SKIP = 0,
   PROCEED,
   ABORT
 };
 
 AutoApproveForTest g_auto_approve_for_test = DO_NOT_SKIP;
 
 // Creates a dummy extension and sets the manifest's name to the item's
 // localized name.
-scoped_refptr<Extension> CreateDummyExtension(const BundleInstaller::Item& item,
-                                              base::DictionaryValue* manifest) {
+scoped_refptr<Extension> CreateDummyExtension(
+    const BundleInstaller::Item& item,
+    base::DictionaryValue* manifest,
+    content::BrowserContext* browser_context) {
   // We require localized names so we can have nice error messages when we can't
   // parse an extension manifest.
   CHECK(!item.localized_name.empty());
 
   std::string error;
-  return Extension::Create(base::FilePath(),
-                           Manifest::INTERNAL,
-                           *manifest,
-                           Extension::NO_FLAGS,
-                           item.id,
-                           &error);
+  scoped_refptr<Extension> extension = Extension::Create(base::FilePath(),
+                                                         Manifest::INTERNAL,
+                                                         *manifest,
+                                                         Extension::NO_FLAGS,
+                                                         item.id,
+                                                         &error);
+  // Initialize permissions so that withheld permissions don't end up in the
+  // install prompt.
+  PermissionsUpdater(browser_context).InitializePermissions(
+      extension.get(), PermissionsUpdater::INIT_FLAG_TRANSIENT);
+  return extension;
 }
 
 bool IsAppPredicate(scoped_refptr<const Extension> extension) {
   return extension->is_app();
 }
 
 struct MatchIdFunctor {
   explicit MatchIdFunctor(const std::string& id) : id(id) {}
   bool operator()(scoped_refptr<const Extension> extension) {
     return extension->id() == id;
@@ skipping 222 matching lines @@
   if (browser_)
     ShowInstalledBubble(this, browser_);
 
   ReportComplete();
 }
 
 void BundleInstaller::OnWebstoreParseSuccess(
     const std::string& id,
     const SkBitmap& icon,
     base::DictionaryValue* manifest) {
-  dummy_extensions_.push_back(CreateDummyExtension(items_[id], manifest));
+  dummy_extensions_.push_back(
+      CreateDummyExtension(items_[id], manifest, profile_));
   parsed_manifests_[id] = linked_ptr<base::DictionaryValue>(manifest);
 
   ShowPromptIfDoneParsing();
 }
 
 void BundleInstaller::OnWebstoreParseFailure(
     const std::string& id,
     WebstoreInstallHelper::Delegate::InstallHelperResultCode result_code,
     const std::string& error_message) {
   items_[id].state = Item::STATE_FAILED;
@@ skipping 36 matching lines @@
 void BundleInstaller::OnBrowserAdded(Browser* browser) {}
 
 void BundleInstaller::OnBrowserRemoved(Browser* browser) {
   if (browser_ == browser)
     browser_ = NULL;
 }
 
 void BundleInstaller::OnBrowserSetLastActive(Browser* browser) {}
 
 }  // namespace extensions