chrome/browser/apps/ephemeral_app_launcher.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/apps/ephemeral_app_launcher.h"
   6
   7 #include "base/command_line.h"
   8 #include "base/strings/utf_string_conversions.h"
   9 #include "chrome/browser/extensions/extension_install_checker.h"
  10 #include "chrome/browser/extensions/extension_install_prompt.h"
  11 #include "chrome/browser/extensions/extension_util.h"
  12 #include "chrome/browser/profiles/profile.h"
  13 #include "chrome/browser/ui/browser_navigator.h"
  14 #include "chrome/browser/ui/extensions/app_launch_params.h"
  15 #include "chrome/browser/ui/extensions/application_launch.h"
  16 #include "chrome/browser/ui/extensions/extension_enable_flow.h"
  17 #include "chrome/browser/ui/native_window_tracker.h"
  18 #include "chrome/browser/ui/scoped_tabbed_browser_displayer.h"
  19 #include "chrome/common/chrome_switches.h"
  20 #include "chrome/common/extensions/manifest_handlers/app_launch_info.h"
  21 #include "content/public/browser/web_contents.h"
  22 #include "extensions/browser/extension_prefs.h"
  23 #include "extensions/browser/extension_registry.h"
  24 #include "extensions/browser/extension_system.h"
  25 #include "extensions/browser/management_policy.h"
  26 #include "extensions/common/constants.h"
  27 #include "extensions/common/permissions/permissions_data.h"
  28 #include "ui/app_list/app_list_switches.h"
  29
  30 using content::WebContents;
  31 using extensions::Extension;
  32 using extensions::ExtensionInstallChecker;
  33 using extensions::ExtensionPrefs;
  34 using extensions::ExtensionRegistry;
  35 using extensions::ExtensionSystem;
  36 using extensions::ManagementPolicy;
  37 using extensions::WebstoreInstaller;
  38 namespace webstore_install = extensions::webstore_install;
  39
  40 namespace {
  41
  42 const char kInvalidManifestError[] = "Invalid manifest";
  43 const char kExtensionTypeError[] = "Not an app";
  44 const char kAppTypeError[] = "Ephemeral legacy packaged apps not supported";
  45 const char kUserCancelledError[] = "Launch cancelled by the user";
  46 const char kBlacklistedError[] = "App is blacklisted for malware";
  47 const char kRequirementsError[] = "App has missing requirements";
  48 const char kFeatureDisabledError[] = "Launching ephemeral apps is not enabled";
  49 const char kMissingAppError[] = "App is not installed";
  50 const char kAppDisabledError[] = "App is disabled";
  51
  52 Profile* ProfileForWebContents(content::WebContents* contents) {
  53   if (!contents)
  54     return NULL;
  55
  56   return Profile::FromBrowserContext(contents->GetBrowserContext());
  57 }
  58
  59 gfx::NativeWindow NativeWindowForWebContents(content::WebContents* contents) {
  60   if (!contents)
  61     return NULL;
  62
  63   return contents->GetTopLevelNativeWindow();
  64 }
  65
  66 // Check whether an extension can be launched. The extension does not need to
  67 // be currently installed.
  68 bool CheckCommonLaunchCriteria(Profile* profile,
  69                                const Extension* extension,
  70                                webstore_install::Result* reason,
  71                                std::string* error) {
  72   // Only apps can be launched.
  73   if (!extension->is_app()) {
  74     *reason = webstore_install::LAUNCH_UNSUPPORTED_EXTENSION_TYPE;
  75     *error = kExtensionTypeError;
  76     return false;
  77   }
  78
  79   // Do not launch apps blocked by management policies.
  80   ManagementPolicy* management_policy =
  81       ExtensionSystem::Get(profile)->management_policy();
  82   base::string16 policy_error;
  83   if (!management_policy->UserMayLoad(extension, &policy_error)) {
  84     *reason = webstore_install::BLOCKED_BY_POLICY;
  85     *error = base::UTF16ToUTF8(policy_error);
  86     return false;
  87   }
  88
  89   return true;
  90 }
  91
  92 }  // namespace
  93
  94 // static
  95 bool EphemeralAppLauncher::IsFeatureEnabled() {
  96   return base::CommandLine::ForCurrentProcess()->HasSwitch(
  97              switches::kEnableEphemeralAppsInWebstore);
  98 }
  99
 100 // static
 101 scoped_refptr<EphemeralAppLauncher> EphemeralAppLauncher::CreateForLauncher(
 102     const std::string& webstore_item_id,
 103     Profile* profile,
 104     gfx::NativeWindow parent_window,
 105     const LaunchCallback& callback) {
 106   scoped_refptr<EphemeralAppLauncher> installer =
 107       new EphemeralAppLauncher(webstore_item_id,
 108                                profile,
 109                                parent_window,
 110                                callback);
 111   installer->set_install_source(WebstoreInstaller::INSTALL_SOURCE_APP_LAUNCHER);
 112   return installer;
 113 }
 114
 115 // static
 116 scoped_refptr<EphemeralAppLauncher> EphemeralAppLauncher::CreateForWebContents(
 117     const std::string& webstore_item_id,
 118     content::WebContents* web_contents,
 119     const LaunchCallback& callback) {
 120   scoped_refptr<EphemeralAppLauncher> installer =
 121       new EphemeralAppLauncher(webstore_item_id, web_contents, callback);
 122   installer->set_install_source(WebstoreInstaller::INSTALL_SOURCE_OTHER);
 123   return installer;
 124 }
 125
 126 void EphemeralAppLauncher::Start() {
 127   if (!IsFeatureEnabled()) {
 128     InvokeCallback(webstore_install::LAUNCH_FEATURE_DISABLED,
 129                    kFeatureDisabledError);
 130     return;
 131   }
 132
 133   // Check whether the app already exists in extension system before downloading
 134   // from the webstore.
 135   const Extension* extension =
 136       ExtensionRegistry::Get(profile())
 137           ->GetExtensionById(id(), ExtensionRegistry::EVERYTHING);
 138   if (extension) {
 139     webstore_install::Result result = webstore_install::OTHER_ERROR;
 140     std::string error;
 141     if (!CanLaunchInstalledApp(extension, &result, &error)) {
 142       InvokeCallback(result, error);
 143       return;
 144     }
 145
 146     if (extensions::util::IsAppLaunchableWithoutEnabling(extension->id(),
 147                                                          profile())) {
 148       LaunchApp(extension);
 149       InvokeCallback(webstore_install::SUCCESS, std::string());
 150       return;
 151     }
 152
 153     EnableInstalledApp(extension);
 154     return;
 155   }
 156
 157   // Install the app ephemerally and launch when complete.
 158   BeginInstall();
 159 }
 160
 161 EphemeralAppLauncher::EphemeralAppLauncher(const std::string& webstore_item_id,
 162                                            Profile* profile,
 163                                            gfx::NativeWindow parent_window,
 164                                            const LaunchCallback& callback)
 165     : WebstoreStandaloneInstaller(webstore_item_id, profile, Callback()),
 166       launch_callback_(callback),
 167       parent_window_(parent_window),
 168       dummy_web_contents_(
 169           WebContents::Create(WebContents::CreateParams(profile))) {
 170    if (parent_window_)
 171      parent_window_tracker_ = NativeWindowTracker::Create(parent_window);
 172 }
 173
 174 EphemeralAppLauncher::EphemeralAppLauncher(const std::string& webstore_item_id,
 175                                            content::WebContents* web_contents,
 176                                            const LaunchCallback& callback)
 177     : WebstoreStandaloneInstaller(webstore_item_id,
 178                                   ProfileForWebContents(web_contents),
 179                                   Callback()),
 180       content::WebContentsObserver(web_contents),
 181       launch_callback_(callback),
 182       parent_window_(NativeWindowForWebContents(web_contents)) {
 183 }
 184
 185 EphemeralAppLauncher::~EphemeralAppLauncher() {}
 186
 187 scoped_ptr<extensions::ExtensionInstallChecker>
 188 EphemeralAppLauncher::CreateInstallChecker() {
 189   return make_scoped_ptr(new ExtensionInstallChecker(profile()));
 190 }
 191
 192 scoped_ptr<ExtensionInstallPrompt> EphemeralAppLauncher::CreateInstallUI() {
 193   if (web_contents())
 194     return make_scoped_ptr(new ExtensionInstallPrompt(web_contents()));
 195
 196   return make_scoped_ptr(new ExtensionInstallPrompt(profile(), parent_window_));
 197 }
 198
 199 scoped_ptr<WebstoreInstaller::Approval> EphemeralAppLauncher::CreateApproval()
 200     const {
 201   scoped_ptr<WebstoreInstaller::Approval> approval =
 202       WebstoreStandaloneInstaller::CreateApproval();
 203   approval->is_ephemeral = true;
 204   return approval.Pass();
 205 }
 206
 207 bool EphemeralAppLauncher::CanLaunchInstalledApp(
 208     const extensions::Extension* extension,
 209     webstore_install::Result* reason,
 210     std::string* error) {
 211   if (!CheckCommonLaunchCriteria(profile(), extension, reason, error))
 212     return false;
 213
 214   // Do not launch blacklisted apps.
 215   if (ExtensionPrefs::Get(profile())->IsExtensionBlacklisted(extension->id())) {
 216     *reason = webstore_install::BLACKLISTED;
 217     *error = kBlacklistedError;
 218     return false;
 219   }
 220
 221   // If the app has missing requirements, it cannot be launched.
 222   if (!extensions::util::IsAppLaunchable(extension->id(), profile())) {
 223     *reason = webstore_install::REQUIREMENT_VIOLATIONS;
 224     *error = kRequirementsError;
 225     return false;
 226   }
 227
 228   return true;
 229 }
 230
 231 void EphemeralAppLauncher::EnableInstalledApp(const Extension* extension) {
 232   // Check whether an install is already in progress.
 233   webstore_install::Result result = webstore_install::OTHER_ERROR;
 234   std::string error;
 235   if (!EnsureUniqueInstall(&result, &error)) {
 236     InvokeCallback(result, error);
 237     return;
 238   }
 239
 240   // Keep this object alive until the enable flow is complete. Either
 241   // ExtensionEnableFlowFinished() or ExtensionEnableFlowAborted() will be
 242   // called.
 243   AddRef();
 244
 245   extension_enable_flow_.reset(
 246       new ExtensionEnableFlow(profile(), extension->id(), this));
 247   if (web_contents())
 248     extension_enable_flow_->StartForWebContents(web_contents());
 249   else
 250     extension_enable_flow_->StartForNativeWindow(parent_window_);
 251 }
 252
 253 void EphemeralAppLauncher::MaybeLaunchApp() {
 254   webstore_install::Result result = webstore_install::OTHER_ERROR;
 255   std::string error;
 256
 257   ExtensionRegistry* registry = ExtensionRegistry::Get(profile());
 258   const Extension* extension =
 259       registry->GetExtensionById(id(), ExtensionRegistry::EVERYTHING);
 260   if (extension) {
 261     // Although the installation was successful, the app may not be
 262     // launchable.
 263     if (registry->enabled_extensions().Contains(extension->id())) {
 264       result = webstore_install::SUCCESS;
 265       LaunchApp(extension);
 266     } else {
 267       error = kAppDisabledError;
 268       // Determine why the app cannot be launched.
 269       CanLaunchInstalledApp(extension, &result, &error);
 270     }
 271   } else {
 272     // The extension must be present in the registry if installed.
 273     NOTREACHED();
 274     error = kMissingAppError;
 275   }
 276
 277   InvokeCallback(result, error);
 278 }
 279
 280 void EphemeralAppLauncher::LaunchApp(const Extension* extension) const {
 281   DCHECK(extension && extension->is_app() &&
 282          ExtensionRegistry::Get(profile())
 283              ->GetExtensionById(extension->id(), ExtensionRegistry::ENABLED));
 284
 285   AppLaunchParams params(profile(), extension, NEW_FOREGROUND_TAB,
 286                          extensions::SOURCE_EPHEMERAL_APP);
 287   params.desktop_type =
 288       chrome::GetHostDesktopTypeForNativeWindow(parent_window_);
 289   OpenApplication(params);
 290 }
 291
 292 bool EphemeralAppLauncher::LaunchHostedApp(const Extension* extension) const {
 293   GURL launch_url = extensions::AppLaunchInfo::GetLaunchWebURL(extension);
 294   if (!launch_url.is_valid())
 295     return false;
 296
 297   chrome::ScopedTabbedBrowserDisplayer displayer(
 298       profile(), chrome::GetHostDesktopTypeForNativeWindow(parent_window_));
 299   chrome::NavigateParams params(
 300       displayer.browser(), launch_url, ui::PAGE_TRANSITION_AUTO_TOPLEVEL);
 301   params.disposition = NEW_FOREGROUND_TAB;
 302   chrome::Navigate(&params);
 303   return true;
 304 }
 305
 306 void EphemeralAppLauncher::InvokeCallback(webstore_install::Result result,
 307                                           const std::string& error) {
 308   if (!launch_callback_.is_null()) {
 309     LaunchCallback callback = launch_callback_;
 310     launch_callback_.Reset();
 311     callback.Run(result, error);
 312   }
 313 }
 314
 315 void EphemeralAppLauncher::AbortLaunch(webstore_install::Result result,
 316                                        const std::string& error) {
 317   InvokeCallback(result, error);
 318   WebstoreStandaloneInstaller::CompleteInstall(result, error);
 319 }
 320
 321 void EphemeralAppLauncher::CheckEphemeralInstallPermitted() {
 322   scoped_refptr<const Extension> extension = GetLocalizedExtensionForDisplay();
 323   DCHECK(extension.get());  // Checked in OnManifestParsed().
 324
 325   install_checker_ = CreateInstallChecker();
 326   DCHECK(install_checker_.get());
 327
 328   install_checker_->set_extension(extension);
 329   install_checker_->Start(ExtensionInstallChecker::CHECK_BLACKLIST |
 330                               ExtensionInstallChecker::CHECK_REQUIREMENTS,
 331                           true,
 332                           base::Bind(&EphemeralAppLauncher::OnInstallChecked,
 333                                      base::Unretained(this)));
 334 }
 335
 336 void EphemeralAppLauncher::OnInstallChecked(int check_failures) {
 337   if (!CheckRequestorAlive()) {
 338     AbortLaunch(webstore_install::OTHER_ERROR, std::string());
 339     return;
 340   }
 341
 342   if (install_checker_->blacklist_state() == extensions::BLACKLISTED_MALWARE) {
 343     AbortLaunch(webstore_install::BLACKLISTED, kBlacklistedError);
 344     return;
 345   }
 346
 347   if (!install_checker_->requirement_errors().empty()) {
 348     AbortLaunch(webstore_install::REQUIREMENT_VIOLATIONS,
 349                 install_checker_->requirement_errors().front());
 350     return;
 351   }
 352
 353   // Proceed with the normal install flow.
 354   ProceedWithInstallPrompt();
 355 }
 356
 357 void EphemeralAppLauncher::InitInstallData(
 358     extensions::ActiveInstallData* install_data) const {
 359   install_data->is_ephemeral = true;
 360 }
 361
 362 bool EphemeralAppLauncher::CheckRequestorAlive() const {
 363   if (!parent_window_) {
 364     // Assume the requestor is always alive if |parent_window_| is null.
 365     return true;
 366   }
 367
 368   return (web_contents() != nullptr ||
 369           (parent_window_tracker_ &&
 370               !parent_window_tracker_->WasNativeWindowClosed()));
 371 }
 372
 373 const GURL& EphemeralAppLauncher::GetRequestorURL() const {
 374   return GURL::EmptyGURL();
 375 }
 376
 377 bool EphemeralAppLauncher::ShouldShowPostInstallUI() const {
 378   return false;
 379 }
 380
 381 bool EphemeralAppLauncher::ShouldShowAppInstalledBubble() const {
 382   return false;
 383 }
 384
 385 WebContents* EphemeralAppLauncher::GetWebContents() const {
 386   return web_contents() ? web_contents() : dummy_web_contents_.get();
 387 }
 388
 389 scoped_refptr<ExtensionInstallPrompt::Prompt>
 390 EphemeralAppLauncher::CreateInstallPrompt() const {
 391   const Extension* extension = localized_extension_for_display();
 392   DCHECK(extension);  // Checked in OnManifestParsed().
 393
 394   // Skip the prompt by returning null if the app does not need to display
 395   // permission warnings.
 396   if (extension->permissions_data()->GetLegacyPermissionMessageStrings()
 397       .empty())
 398     return NULL;
 399
 400   return make_scoped_refptr(new ExtensionInstallPrompt::Prompt(
 401       ExtensionInstallPrompt::LAUNCH_PROMPT));
 402 }
 403
 404 bool EphemeralAppLauncher::CheckInlineInstallPermitted(
 405     const base::DictionaryValue& webstore_data,
 406     std::string* error) const {
 407   *error = "";
 408   return true;
 409 }
 410
 411 bool EphemeralAppLauncher::CheckRequestorPermitted(
 412     const base::DictionaryValue& webstore_data,
 413     std::string* error) const {
 414   *error = "";
 415   return true;
 416 }
 417
 418 void EphemeralAppLauncher::OnManifestParsed() {
 419   scoped_refptr<const Extension> extension = GetLocalizedExtensionForDisplay();
 420   if (!extension.get()) {
 421     AbortLaunch(webstore_install::INVALID_MANIFEST, kInvalidManifestError);
 422     return;
 423   }
 424
 425   webstore_install::Result result = webstore_install::OTHER_ERROR;
 426   std::string error;
 427   if (!CheckCommonLaunchCriteria(profile(), extension.get(), &result, &error)) {
 428     AbortLaunch(result, error);
 429     return;
 430   }
 431
 432   if (extension->is_legacy_packaged_app()) {
 433     AbortLaunch(webstore_install::LAUNCH_UNSUPPORTED_EXTENSION_TYPE,
 434                 kAppTypeError);
 435     return;
 436   }
 437
 438   if (extension->is_hosted_app()) {
 439     // Hosted apps do not need to be installed ephemerally. Just navigate to
 440     // their launch url.
 441     if (LaunchHostedApp(extension.get()))
 442       AbortLaunch(webstore_install::SUCCESS, std::string());
 443     else
 444       AbortLaunch(webstore_install::INVALID_MANIFEST, kInvalidManifestError);
 445     return;
 446   }
 447
 448   CheckEphemeralInstallPermitted();
 449 }
 450
 451 void EphemeralAppLauncher::CompleteInstall(webstore_install::Result result,
 452                                            const std::string& error) {
 453   if (result == webstore_install::SUCCESS)
 454     MaybeLaunchApp();
 455   else if (!launch_callback_.is_null())
 456     InvokeCallback(result, error);
 457
 458   WebstoreStandaloneInstaller::CompleteInstall(result, error);
 459 }
 460
 461 void EphemeralAppLauncher::WebContentsDestroyed() {
 462   launch_callback_.Reset();
 463   AbortInstall();
 464 }
 465
 466 void EphemeralAppLauncher::ExtensionEnableFlowFinished() {
 467   MaybeLaunchApp();
 468
 469   // CompleteInstall will call Release.
 470   WebstoreStandaloneInstaller::CompleteInstall(webstore_install::SUCCESS,
 471                                                std::string());
 472 }
 473
 474 void EphemeralAppLauncher::ExtensionEnableFlowAborted(bool user_initiated) {
 475   // CompleteInstall will call Release.
 476   CompleteInstall(webstore_install::USER_CANCELLED, kUserCancelledError);
 477 }