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