Home | History | Annotate | Download | only in extensions 
      1 // Copyright (c) 2012 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/ui/extensions/application_launch.h"
      6 
      7 #include <string>
      8 
      9 #include "apps/launcher.h"
     10 #include "base/command_line.h"
     11 #include "base/metrics/histogram.h"
     12 #include "base/strings/utf_string_conversions.h"
     13 #include "chrome/browser/app_mode/app_mode_utils.h"
     14 #include "chrome/browser/apps/per_app_settings_service.h"
     15 #include "chrome/browser/apps/per_app_settings_service_factory.h"
     16 #include "chrome/browser/extensions/extension_service.h"
     17 #include "chrome/browser/extensions/launch_util.h"
     18 #include "chrome/browser/extensions/tab_helper.h"
     19 #include "chrome/browser/profiles/profile.h"
     20 #include "chrome/browser/ui/app_list/app_list_service.h"
     21 #include "chrome/browser/ui/browser.h"
     22 #include "chrome/browser/ui/browser_commands.h"
     23 #include "chrome/browser/ui/browser_finder.h"
     24 #include "chrome/browser/ui/browser_tabstrip.h"
     25 #include "chrome/browser/ui/browser_window.h"
     26 #include "chrome/browser/ui/extensions/extension_enable_flow.h"
     27 #include "chrome/browser/ui/extensions/extension_enable_flow_delegate.h"
     28 #include "chrome/browser/ui/tabs/tab_strip_model.h"
     29 #include "chrome/browser/web_applications/web_app.h"
     30 #include "chrome/common/chrome_switches.h"
     31 #include "chrome/common/extensions/manifest_handlers/app_launch_info.h"
     32 #include "chrome/common/url_constants.h"
     33 #include "content/public/browser/render_view_host.h"
     34 #include "content/public/browser/web_contents.h"
     35 #include "content/public/common/renderer_preferences.h"
     36 #include "extensions/browser/extension_prefs.h"
     37 #include "extensions/browser/extension_registry.h"
     38 #include "extensions/browser/extension_system.h"
     39 #include "extensions/common/constants.h"
     40 #include "extensions/common/extension.h"
     41 #include "extensions/common/features/feature.h"
     42 #include "extensions/common/features/feature_provider.h"
     43 #include "extensions/common/manifest_handlers/options_page_info.h"
     44 #include "ui/base/window_open_disposition.h"
     45 #include "ui/gfx/rect.h"
     46 
     47 #if defined(OS_MACOSX)
     48 #include "chrome/browser/ui/browser_commands_mac.h"
     49 #endif
     50 
     51 using content::WebContents;
     52 using extensions::Extension;
     53 using extensions::ExtensionPrefs;
     54 using extensions::ExtensionRegistry;
     55 
     56 namespace {
     57 
     58 // Attempts to launch a packaged app, prompting the user to enable it if
     59 // necessary. If a prompt is required it will be shown inside the AppList.
     60 // This class manages its own lifetime.
     61 class EnableViaAppListFlow : public ExtensionEnableFlowDelegate {
     62  public:
     63   EnableViaAppListFlow(ExtensionService* service,
     64                        Profile* profile,
     65                        chrome::HostDesktopType desktop_type,
     66                        const std::string& extension_id,
     67                        const base::Closure& callback)
     68       : service_(service),
     69         profile_(profile),
     70         desktop_type_(desktop_type),
     71         extension_id_(extension_id),
     72         callback_(callback) {
     73   }
     74 
     75   virtual ~EnableViaAppListFlow() {
     76   }
     77 
     78   void Run() {
     79     DCHECK(!service_->IsExtensionEnabled(extension_id_));
     80     flow_.reset(new ExtensionEnableFlow(profile_, extension_id_, this));
     81     flow_->StartForCurrentlyNonexistentWindow(
     82         base::Bind(&EnableViaAppListFlow::ShowAppList, base::Unretained(this)));
     83   }
     84 
     85  private:
     86   gfx::NativeWindow ShowAppList() {
     87     AppListService* app_list_service = AppListService::Get(desktop_type_);
     88     app_list_service->Show();
     89     return app_list_service->GetAppListWindow();
     90   }
     91 
     92   // ExtensionEnableFlowDelegate overrides.
     93   virtual void ExtensionEnableFlowFinished() OVERRIDE {
     94     const Extension* extension =
     95         service_->GetExtensionById(extension_id_, false);
     96     if (!extension)
     97       return;
     98     callback_.Run();
     99     delete this;
    100   }
    101 
    102   virtual void ExtensionEnableFlowAborted(bool user_initiated) OVERRIDE {
    103     delete this;
    104   }
    105 
    106   ExtensionService* service_;
    107   Profile* profile_;
    108   chrome::HostDesktopType desktop_type_;
    109   std::string extension_id_;
    110   base::Closure callback_;
    111   scoped_ptr<ExtensionEnableFlow> flow_;
    112 
    113   DISALLOW_COPY_AND_ASSIGN(EnableViaAppListFlow);
    114 };
    115 
    116 const Extension* GetExtension(const AppLaunchParams& params) {
    117   if (params.extension_id.empty())
    118     return NULL;
    119   ExtensionRegistry* registry = ExtensionRegistry::Get(params.profile);
    120   return registry->GetExtensionById(params.extension_id,
    121                                     ExtensionRegistry::ENABLED |
    122                                         ExtensionRegistry::DISABLED |
    123                                         ExtensionRegistry::TERMINATED);
    124 }
    125 
    126 ui::WindowShowState DetermineWindowShowState(
    127     Profile* profile,
    128     extensions::LaunchContainer container,
    129     const Extension* extension) {
    130   if (!extension || container != extensions::LAUNCH_CONTAINER_WINDOW)
    131     return ui::SHOW_STATE_DEFAULT;
    132 
    133   if (chrome::IsRunningInForcedAppMode())
    134     return ui::SHOW_STATE_FULLSCREEN;
    135 
    136 #if defined(USE_ASH)
    137   // In ash, LAUNCH_TYPE_FULLSCREEN launches in a maximized app window and
    138   // LAUNCH_TYPE_WINDOW launches in a normal app window.
    139   extensions::LaunchType launch_type =
    140       extensions::GetLaunchType(ExtensionPrefs::Get(profile), extension);
    141   if (launch_type == extensions::LAUNCH_TYPE_FULLSCREEN)
    142     return ui::SHOW_STATE_MAXIMIZED;
    143   else if (launch_type == extensions::LAUNCH_TYPE_WINDOW)
    144     return ui::SHOW_STATE_NORMAL;
    145 #endif
    146 
    147   return ui::SHOW_STATE_DEFAULT;
    148 }
    149 
    150 WebContents* OpenApplicationWindow(const AppLaunchParams& params) {
    151   Profile* const profile = params.profile;
    152   const Extension* const extension = GetExtension(params);
    153   const GURL url_input = params.override_url;
    154 
    155   DCHECK(!url_input.is_empty() || extension);
    156   GURL url = UrlForExtension(extension, url_input);
    157   std::string app_name = extension ?
    158       web_app::GenerateApplicationNameFromExtensionId(extension->id()) :
    159       web_app::GenerateApplicationNameFromURL(url);
    160 
    161   gfx::Rect initial_bounds;
    162   if (!params.override_bounds.IsEmpty()) {
    163     initial_bounds = params.override_bounds;
    164   } else if (extension) {
    165     initial_bounds.set_width(
    166         extensions::AppLaunchInfo::GetLaunchWidth(extension));
    167     initial_bounds.set_height(
    168         extensions::AppLaunchInfo::GetLaunchHeight(extension));
    169   }
    170 
    171   Browser::CreateParams browser_params(
    172       Browser::CreateParams::CreateForApp(app_name,
    173                                           true /* trusted_source */,
    174                                           initial_bounds,
    175                                           profile,
    176                                           params.desktop_type));
    177 
    178   browser_params.initial_show_state = DetermineWindowShowState(profile,
    179                                                                params.container,
    180                                                                extension);
    181 
    182   Browser* browser = new Browser(browser_params);
    183 
    184   WebContents* web_contents = chrome::AddSelectedTabWithURL(
    185       browser, url, ui::PAGE_TRANSITION_AUTO_TOPLEVEL);
    186   web_contents->GetMutableRendererPrefs()->can_accept_load_drops = false;
    187   web_contents->GetRenderViewHost()->SyncRendererPrefs();
    188 
    189   browser->window()->Show();
    190 
    191   // TODO(jcampan): http://crbug.com/8123 we should not need to set the initial
    192   //                focus explicitly.
    193   web_contents->SetInitialFocus();
    194   return web_contents;
    195 }
    196 
    197 WebContents* OpenApplicationTab(const AppLaunchParams& launch_params) {
    198   const Extension* extension = GetExtension(launch_params);
    199   CHECK(extension);
    200   Profile* const profile = launch_params.profile;
    201   WindowOpenDisposition disposition = launch_params.disposition;
    202 
    203   Browser* browser = chrome::FindTabbedBrowser(profile,
    204                                                false,
    205                                                launch_params.desktop_type);
    206   WebContents* contents = NULL;
    207   if (!browser) {
    208     // No browser for this profile, need to open a new one.
    209     browser = new Browser(Browser::CreateParams(Browser::TYPE_TABBED,
    210                                                 profile,
    211                                                 launch_params.desktop_type));
    212     browser->window()->Show();
    213     // There's no current tab in this browser window, so add a new one.
    214     disposition = NEW_FOREGROUND_TAB;
    215   } else {
    216     // For existing browser, ensure its window is shown and activated.
    217     browser->window()->Show();
    218     browser->window()->Activate();
    219   }
    220 
    221   extensions::LaunchType launch_type =
    222       extensions::GetLaunchType(ExtensionPrefs::Get(profile), extension);
    223   UMA_HISTOGRAM_ENUMERATION("Extensions.AppTabLaunchType", launch_type, 100);
    224 
    225   int add_type = TabStripModel::ADD_ACTIVE;
    226   if (launch_type == extensions::LAUNCH_TYPE_PINNED)
    227     add_type |= TabStripModel::ADD_PINNED;
    228 
    229   GURL extension_url = UrlForExtension(extension, launch_params.override_url);
    230   chrome::NavigateParams params(browser, extension_url,
    231                                 ui::PAGE_TRANSITION_AUTO_TOPLEVEL);
    232   params.tabstrip_add_types = add_type;
    233   params.disposition = disposition;
    234 
    235   if (disposition == CURRENT_TAB) {
    236     WebContents* existing_tab =
    237         browser->tab_strip_model()->GetActiveWebContents();
    238     TabStripModel* model = browser->tab_strip_model();
    239     int tab_index = model->GetIndexOfWebContents(existing_tab);
    240 
    241     existing_tab->OpenURL(content::OpenURLParams(
    242           extension_url,
    243           content::Referrer(existing_tab->GetURL(),
    244                             blink::WebReferrerPolicyDefault),
    245           disposition, ui::PAGE_TRANSITION_LINK, false));
    246     // Reset existing_tab as OpenURL() may have clobbered it.
    247     existing_tab = browser->tab_strip_model()->GetActiveWebContents();
    248     if (params.tabstrip_add_types & TabStripModel::ADD_PINNED) {
    249       model->SetTabPinned(tab_index, true);
    250       // Pinning may have moved the tab.
    251       tab_index = model->GetIndexOfWebContents(existing_tab);
    252     }
    253     if (params.tabstrip_add_types & TabStripModel::ADD_ACTIVE)
    254       model->ActivateTabAt(tab_index, true);
    255 
    256     contents = existing_tab;
    257   } else {
    258     chrome::Navigate(&params);
    259     contents = params.target_contents;
    260   }
    261 
    262   // On Chrome OS the host desktop type for a browser window is always set to
    263   // HOST_DESKTOP_TYPE_ASH. On Windows 8 it is only the case for Chrome ASH
    264   // in metro mode.
    265   if (browser->host_desktop_type() == chrome::HOST_DESKTOP_TYPE_ASH) {
    266     // In ash, LAUNCH_FULLSCREEN launches in the OpenApplicationWindow function
    267     // i.e. it should not reach here.
    268     DCHECK(launch_type != extensions::LAUNCH_TYPE_FULLSCREEN);
    269   } else {
    270     // TODO(skerner):  If we are already in full screen mode, and the user
    271     // set the app to open as a regular or pinned tab, what should happen?
    272     // Today we open the tab, but stay in full screen mode.  Should we leave
    273     // full screen mode in this case?
    274     if (launch_type == extensions::LAUNCH_TYPE_FULLSCREEN &&
    275         !browser->window()->IsFullscreen()) {
    276 #if defined(OS_MACOSX)
    277       chrome::ToggleFullscreenWithChromeOrFallback(browser);
    278 #else
    279       chrome::ToggleFullscreenMode(browser);
    280 #endif
    281     }
    282   }
    283   return contents;
    284 }
    285 
    286 WebContents* OpenEnabledApplication(const AppLaunchParams& params) {
    287   const Extension* extension = GetExtension(params);
    288   if (!extension)
    289     return NULL;
    290   Profile* profile = params.profile;
    291 
    292   WebContents* tab = NULL;
    293   ExtensionPrefs* prefs = ExtensionPrefs::Get(profile);
    294   prefs->SetActiveBit(extension->id(), true);
    295 
    296   UMA_HISTOGRAM_ENUMERATION(
    297       "Extensions.AppLaunchContainer", params.container, 100);
    298 
    299   if (CanLaunchViaEvent(extension)) {
    300     // Remember what desktop the launch happened on so that when the app opens a
    301     // window we can open them on the right desktop.
    302     PerAppSettingsServiceFactory::GetForBrowserContext(profile)->
    303         SetDesktopLastLaunchedFrom(extension->id(), params.desktop_type);
    304 
    305     apps::LaunchPlatformAppWithCommandLine(
    306         profile, extension, params.command_line, params.current_directory);
    307     return NULL;
    308   }
    309 
    310   // Record v1 app launch. Platform app launch is recorded when dispatching
    311   // the onLaunched event.
    312   prefs->SetLastLaunchTime(extension->id(), base::Time::Now());
    313 
    314   switch (params.container) {
    315     case extensions::LAUNCH_CONTAINER_NONE: {
    316       NOTREACHED();
    317       break;
    318     }
    319     case extensions::LAUNCH_CONTAINER_PANEL:
    320     case extensions::LAUNCH_CONTAINER_WINDOW:
    321       tab = OpenApplicationWindow(params);
    322       break;
    323     case extensions::LAUNCH_CONTAINER_TAB: {
    324       tab = OpenApplicationTab(params);
    325       break;
    326     }
    327     default:
    328       NOTREACHED();
    329       break;
    330   }
    331   return tab;
    332 }
    333 
    334 }  // namespace
    335 
    336 AppLaunchParams::AppLaunchParams(Profile* profile,
    337                                  const extensions::Extension* extension,
    338                                  extensions::LaunchContainer container,
    339                                  WindowOpenDisposition disposition)
    340     : profile(profile),
    341       extension_id(extension ? extension->id() : std::string()),
    342       container(container),
    343       disposition(disposition),
    344       desktop_type(chrome::GetActiveDesktop()),
    345       override_url(),
    346       override_bounds(),
    347       command_line(CommandLine::NO_PROGRAM) {}
    348 
    349 AppLaunchParams::AppLaunchParams(Profile* profile,
    350                                  const extensions::Extension* extension,
    351                                  WindowOpenDisposition disposition)
    352     : profile(profile),
    353       extension_id(extension ? extension->id() : std::string()),
    354       container(extensions::LAUNCH_CONTAINER_NONE),
    355       disposition(disposition),
    356       desktop_type(chrome::GetActiveDesktop()),
    357       override_url(),
    358       override_bounds(),
    359       command_line(CommandLine::NO_PROGRAM) {
    360   // Look up the app preference to find out the right launch container. Default
    361   // is to launch as a regular tab.
    362   container =
    363       extensions::GetLaunchContainer(ExtensionPrefs::Get(profile), extension);
    364 }
    365 
    366 AppLaunchParams::AppLaunchParams(Profile* profile,
    367                                  const extensions::Extension* extension,
    368                                  int event_flags,
    369                                  chrome::HostDesktopType desktop_type)
    370     : profile(profile),
    371       extension_id(extension ? extension->id() : std::string()),
    372       container(extensions::LAUNCH_CONTAINER_NONE),
    373       disposition(ui::DispositionFromEventFlags(event_flags)),
    374       desktop_type(desktop_type),
    375       override_url(),
    376       override_bounds(),
    377       command_line(CommandLine::NO_PROGRAM) {
    378   if (disposition == NEW_FOREGROUND_TAB || disposition == NEW_BACKGROUND_TAB) {
    379     container = extensions::LAUNCH_CONTAINER_TAB;
    380   } else if (disposition == NEW_WINDOW) {
    381     container = extensions::LAUNCH_CONTAINER_WINDOW;
    382   } else {
    383     // Look at preference to find the right launch container.  If no preference
    384     // is set, launch as a regular tab.
    385     container =
    386         extensions::GetLaunchContainer(ExtensionPrefs::Get(profile), extension);
    387     disposition = NEW_FOREGROUND_TAB;
    388   }
    389 }
    390 
    391 AppLaunchParams::~AppLaunchParams() {
    392 }
    393 
    394 WebContents* OpenApplication(const AppLaunchParams& params) {
    395   return OpenEnabledApplication(params);
    396 }
    397 
    398 void OpenApplicationWithReenablePrompt(const AppLaunchParams& params) {
    399   const Extension* extension = GetExtension(params);
    400   if (!extension)
    401     return;
    402   Profile* profile = params.profile;
    403 
    404   ExtensionService* service =
    405       extensions::ExtensionSystem::Get(profile)->extension_service();
    406   if (!service->IsExtensionEnabled(extension->id()) ||
    407       extensions::ExtensionRegistry::Get(profile)->GetExtensionById(
    408           extension->id(), extensions::ExtensionRegistry::TERMINATED)) {
    409     (new EnableViaAppListFlow(
    410         service, profile, params.desktop_type, extension->id(),
    411         base::Bind(base::IgnoreResult(OpenEnabledApplication), params)))->Run();
    412     return;
    413   }
    414 
    415   OpenEnabledApplication(params);
    416 }
    417 
    418 WebContents* OpenAppShortcutWindow(Profile* profile,
    419                                    const GURL& url) {
    420   AppLaunchParams launch_params(
    421       profile,
    422       NULL,  // this is a URL app.  No extension.
    423       extensions::LAUNCH_CONTAINER_WINDOW,
    424       NEW_WINDOW);
    425   launch_params.override_url = url;
    426 
    427   WebContents* tab = OpenApplicationWindow(launch_params);
    428 
    429   if (!tab)
    430     return NULL;
    431 
    432   extensions::TabHelper::FromWebContents(tab)->UpdateShortcutOnLoadComplete();
    433 
    434   return tab;
    435 }
    436 
    437 bool CanLaunchViaEvent(const extensions::Extension* extension) {
    438   const extensions::FeatureProvider* feature_provider =
    439       extensions::FeatureProvider::GetAPIFeatures();
    440   extensions::Feature* feature = feature_provider->GetFeature("app.runtime");
    441   return feature->IsAvailableToExtension(extension).is_available();
    442 }
    443 
    444 GURL UrlForExtension(const Extension* extension, const GURL& override_url) {
    445   if (!extension)
    446     return override_url;
    447 
    448   GURL url;
    449   if (!override_url.is_empty()) {
    450     DCHECK(extension->web_extent().MatchesURL(override_url) ||
    451            override_url.GetOrigin() == extension->url());
    452     url = override_url;
    453   } else {
    454     url = extensions::AppLaunchInfo::GetFullLaunchURL(extension);
    455   }
    456 
    457   // For extensions lacking launch urls, determine a reasonable fallback.
    458   if (!url.is_valid()) {
    459     url = extensions::OptionsPageInfo::GetOptionsPage(extension);
    460     if (!url.is_valid())
    461       url = GURL(chrome::kChromeUIExtensionsURL);
    462   }
    463 
    464   return url;
    465 }
    466