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