[Canceled] Extensions: Add install_flags parameter to ManagementPolicy::UserMayLoad

chrome/browser/apps/ephemeral_app_launcher.cc

 // Copyright 2013 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/apps/ephemeral_app_launcher.h"
 
 #include "base/command_line.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/extensions/extension_install_checker.h"
 #include "chrome/browser/extensions/extension_install_prompt.h"
 #include "chrome/browser/extensions/extension_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/browser/ui/extensions/application_launch.h"
 #include "chrome/browser/ui/extensions/extension_enable_flow.h"
 #include "chrome/browser/ui/scoped_tabbed_browser_displayer.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/manifest_handlers/app_launch_info.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
+#include "extensions/browser/install_flag.h"
 #include "extensions/browser/management_policy.h"
 #include "extensions/common/permissions/permissions_data.h"
 
 using content::WebContents;
 using extensions::Extension;
 using extensions::ExtensionInstallChecker;
 using extensions::ExtensionPrefs;
 using extensions::ExtensionRegistry;
 using extensions::ExtensionSystem;
 using extensions::ManagementPolicy;
 using extensions::WebstoreInstaller;
 namespace webstore_install = extensions::webstore_install;
 
 namespace {
 
 const char kInvalidManifestError[] = "Invalid manifest";
 const char kExtensionTypeError[] = "Not an app";
 const char kAppTypeError[] = "Ephemeral legacy packaged apps not supported";
 const char kUserCancelledError[] = "Launch cancelled by the user";
 const char kBlacklistedError[] = "App is blacklisted for malware";
 const char kRequirementsError[] = "App has missing requirements";
 const char kFeatureDisabledError[] = "Launching ephemeral apps is not enabled";
 const char kMissingAppError[] = "App is not installed";
 const char kAppDisabledError[] = "App is disabled";
 
+const int kInstallFlags = extensions::kInstallFlagIsEphemeral;
+
 Profile* ProfileForWebContents(content::WebContents* contents) {
   if (!contents)
     return NULL;
 
   return Profile::FromBrowserContext(contents->GetBrowserContext());
 }
 
 gfx::NativeWindow NativeWindowForWebContents(content::WebContents* contents) {
   if (!contents)
     return NULL;
 
   return contents->GetTopLevelNativeWindow();
 }
 
 // Check whether an extension can be launched. The extension does not need to
 // be currently installed.
 bool CheckCommonLaunchCriteria(Profile* profile,
                                const Extension* extension,
+                               int install_flags,
                                webstore_install::Result* reason,
                                std::string* error) {
   // Only apps can be launched.
   if (!extension->is_app()) {
     *reason = webstore_install::LAUNCH_UNSUPPORTED_EXTENSION_TYPE;
     *error = kExtensionTypeError;
     return false;
   }
 
   // Do not launch apps blocked by management policies.
   ManagementPolicy* management_policy =
       ExtensionSystem::Get(profile)->management_policy();
   base::string16 policy_error;
-  if (!management_policy->UserMayLoad(extension, &policy_error)) {
+  if (!management_policy->UserMayLoad(
+          extension, install_flags, &policy_error)) {
     *reason = webstore_install::BLOCKED_BY_POLICY;
     *error = base::UTF16ToUTF8(policy_error);
     return false;
   }
 
   return true;
 }
 
 }  // namespace
 
@@ skipping 106 matching lines @@
   scoped_ptr<WebstoreInstaller::Approval> approval =
       WebstoreStandaloneInstaller::CreateApproval();
   approval->is_ephemeral = true;
   return approval.Pass();
 }
 
 bool EphemeralAppLauncher::CanLaunchInstalledApp(
     const extensions::Extension* extension,
     webstore_install::Result* reason,
     std::string* error) {
-  if (!CheckCommonLaunchCriteria(profile(), extension, reason, error))
+  ExtensionPrefs* extension_prefs = ExtensionPrefs::Get(profile());
+  int install_flags = extension_prefs->GetInstallFlags(extension->id());
+  if (!CheckCommonLaunchCriteria(
+          profile(), extension, install_flags, reason, error))
     return false;
 
   // Do not launch blacklisted apps.
-  if (ExtensionPrefs::Get(profile())->IsExtensionBlacklisted(extension->id())) {
+  if (extension_prefs->IsExtensionBlacklisted(extension->id())) {
     *reason = webstore_install::BLACKLISTED;
     *error = kBlacklistedError;
     return false;
   }
 
   // If the app has missing requirements, it cannot be launched.
   if (!extensions::util::IsAppLaunchable(extension->id(), profile())) {
     *reason = webstore_install::REQUIREMENT_VIOLATIONS;
     *error = kRequirementsError;
     return false;
@@ skipping 82 matching lines @@
   WebstoreStandaloneInstaller::CompleteInstall(result, error);
 }
 
 void EphemeralAppLauncher::CheckEphemeralInstallPermitted() {
   scoped_refptr<const Extension> extension = GetLocalizedExtensionForDisplay();
   DCHECK(extension.get());  // Checked in OnManifestParsed().
 
   install_checker_ = CreateInstallChecker();
   DCHECK(install_checker_.get());
 
-  install_checker_->set_extension(extension);
+  install_checker_->set_extension(extension, kInstallFlags);
   install_checker_->Start(ExtensionInstallChecker::CHECK_BLACKLIST |
                               ExtensionInstallChecker::CHECK_REQUIREMENTS,
                           true,
                           base::Bind(&EphemeralAppLauncher::OnInstallChecked,
                                      base::Unretained(this)));
 }
 
 void EphemeralAppLauncher::OnInstallChecked(int check_failures) {
   if (!CheckRequestorAlive()) {
     AbortLaunch(webstore_install::UNKNOWN_ERROR, std::string());
@@ skipping 67 matching lines @@
 
 void EphemeralAppLauncher::OnManifestParsed() {
   const Extension* extension = GetLocalizedExtensionForDisplay();
   if (!extension) {
     AbortLaunch(webstore_install::INVALID_MANIFEST, kInvalidManifestError);
     return;
   }
 
   webstore_install::Result result = webstore_install::UNKNOWN_ERROR;
   std::string error;
-  if (!CheckCommonLaunchCriteria(profile(), extension, &result, &error)) {
+  if (!CheckCommonLaunchCriteria(
+          profile(), extension, kInstallFlags, &result, &error)) {
     AbortLaunch(result, error);
     return;
   }
 
   if (extension->is_legacy_packaged_app()) {
     AbortLaunch(webstore_install::LAUNCH_UNSUPPORTED_EXTENSION_TYPE,
                 kAppTypeError);
     return;
   }
 
@@ skipping 27 matching lines @@
 
 void EphemeralAppLauncher::ExtensionEnableFlowFinished() {
   MaybeLaunchApp();
   Release();  // Matches the AddRef in EnableInstalledApp().
 }
 
 void EphemeralAppLauncher::ExtensionEnableFlowAborted(bool user_initiated) {
   InvokeCallback(webstore_install::USER_CANCELLED, kUserCancelledError);
   Release();  // Matches the AddRef in EnableInstalledApp().
 }