extension_tab_util.cc revision e4256316f8b5e8d1ec0df1f7762771622a53fa63 
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/extensions/extension_tab_util.h"
6
7#include "base/strings/string_number_conversions.h"
8#include "base/strings/stringprintf.h"
9#include "chrome/browser/extensions/api/tabs/tabs_constants.h"
10#include "chrome/browser/extensions/chrome_extension_function.h"
11#include "chrome/browser/extensions/chrome_extension_function_details.h"
12#include "chrome/browser/extensions/tab_helper.h"
13#include "chrome/browser/extensions/window_controller.h"
14#include "chrome/browser/extensions/window_controller_list.h"
15#include "chrome/browser/profiles/profile.h"
16#include "chrome/browser/sessions/session_tab_helper.h"
17#include "chrome/browser/ui/browser.h"
18#include "chrome/browser/ui/browser_finder.h"
19#include "chrome/browser/ui/browser_iterator.h"
20#include "chrome/browser/ui/browser_window.h"
21#include "chrome/browser/ui/scoped_tabbed_browser_displayer.h"
22#include "chrome/browser/ui/singleton_tabs.h"
23#include "chrome/browser/ui/tab_contents/tab_contents_iterator.h"
24#include "chrome/browser/ui/tabs/tab_strip_model.h"
25#include "chrome/common/extensions/api/tabs.h"
26#include "chrome/common/url_constants.h"
27#include "components/url_fixer/url_fixer.h"
28#include "content/public/browser/favicon_status.h"
29#include "content/public/browser/navigation_entry.h"
30#include "content/public/browser/web_contents.h"
31#include "extensions/browser/app_window/app_window.h"
32#include "extensions/browser/app_window/app_window_registry.h"
33#include "extensions/common/constants.h"
34#include "extensions/common/error_utils.h"
35#include "extensions/common/extension.h"
36#include "extensions/common/feature_switch.h"
37#include "extensions/common/manifest_constants.h"
38#include "extensions/common/manifest_handlers/incognito_info.h"
39#include "extensions/common/manifest_handlers/options_page_info.h"
40#include "extensions/common/permissions/api_permission.h"
41#include "extensions/common/permissions/permissions_data.h"
42#include "url/gurl.h"
43
44using content::NavigationEntry;
45using content::WebContents;
46
47namespace extensions {
48
49namespace {
50
51namespace keys = tabs_constants;
52
53WindowController* GetAppWindowController(const WebContents* contents) {
54  Profile* profile = Profile::FromBrowserContext(contents->GetBrowserContext());
55  AppWindowRegistry* registry = AppWindowRegistry::Get(profile);
56  if (!registry)
57    return NULL;
58  AppWindow* app_window =
59      registry->GetAppWindowForRenderViewHost(contents->GetRenderViewHost());
60  if (!app_window)
61    return NULL;
62  return WindowControllerList::GetInstance()->FindWindowById(
63      app_window->session_id().id());
64}
65
66// |error_message| can optionally be passed in and will be set with an
67// appropriate message if the window cannot be found by id.
68Browser* GetBrowserInProfileWithId(Profile* profile,
69                                   const int window_id,
70                                   bool include_incognito,
71                                   std::string* error_message) {
72  Profile* incognito_profile =
73      include_incognito && profile->HasOffTheRecordProfile()
74          ? profile->GetOffTheRecordProfile()
75          : NULL;
76  for (chrome::BrowserIterator it; !it.done(); it.Next()) {
77    Browser* browser = *it;
78    if ((browser->profile() == profile ||
79         browser->profile() == incognito_profile) &&
80        ExtensionTabUtil::GetWindowId(browser) == window_id &&
81        browser->window()) {
82      return browser;
83    }
84  }
85
86  if (error_message)
87    *error_message = ErrorUtils::FormatErrorMessage(
88        keys::kWindowNotFoundError, base::IntToString(window_id));
89
90  return NULL;
91}
92
93Browser* CreateBrowser(ChromeUIThreadExtensionFunction* function,
94                       int window_id,
95                       std::string* error) {
96  content::WebContents* web_contents = function->GetAssociatedWebContents();
97  chrome::HostDesktopType desktop_type =
98      web_contents && web_contents->GetNativeView()
99          ? chrome::GetHostDesktopTypeForNativeView(
100                web_contents->GetNativeView())
101          : chrome::GetHostDesktopTypeForNativeView(NULL);
102  Browser::CreateParams params(
103      Browser::TYPE_TABBED, function->GetProfile(), desktop_type);
104  Browser* browser = new Browser(params);
105  browser->window()->Show();
106  return browser;
107}
108
109}  // namespace
110
111ExtensionTabUtil::OpenTabParams::OpenTabParams()
112    : create_browser_if_needed(false) {
113}
114
115ExtensionTabUtil::OpenTabParams::~OpenTabParams() {
116}
117
118// Opens a new tab for a given extension. Returns NULL and sets |error| if an
119// error occurs.
120base::DictionaryValue* ExtensionTabUtil::OpenTab(
121    ChromeUIThreadExtensionFunction* function,
122    const OpenTabParams& params,
123    std::string* error) {
124  // windowId defaults to "current" window.
125  int window_id = extension_misc::kCurrentWindowId;
126  if (params.window_id.get())
127    window_id = *params.window_id;
128
129  Browser* browser = GetBrowserFromWindowID(function, window_id, error);
130  if (!browser) {
131    if (!params.create_browser_if_needed) {
132      return NULL;
133    }
134    browser = CreateBrowser(function, window_id, error);
135    if (!browser)
136      return NULL;
137  }
138
139  // Ensure the selected browser is tabbed.
140  if (!browser->is_type_tabbed() && browser->IsAttemptingToCloseBrowser())
141    browser = chrome::FindTabbedBrowser(function->GetProfile(),
142                                        function->include_incognito(),
143                                        browser->host_desktop_type());
144
145  if (!browser || !browser->window()) {
146    // TODO(rpaquay): Error message?
147    return NULL;
148  }
149
150  // TODO(jstritar): Add a constant, chrome.tabs.TAB_ID_ACTIVE, that
151  // represents the active tab.
152  WebContents* opener = NULL;
153  if (params.opener_tab_id.get()) {
154    int opener_id = *params.opener_tab_id;
155
156    if (!ExtensionTabUtil::GetTabById(opener_id,
157                                      function->GetProfile(),
158                                      function->include_incognito(),
159                                      NULL,
160                                      NULL,
161                                      &opener,
162                                      NULL)) {
163      // TODO(rpaquay): Error message?
164      return NULL;
165    }
166  }
167
168  // TODO(rafaelw): handle setting remaining tab properties:
169  // -title
170  // -favIconUrl
171
172  GURL url;
173  if (params.url.get()) {
174    std::string url_string= *params.url;
175    url = ExtensionTabUtil::ResolvePossiblyRelativeURL(url_string,
176                                                       function->extension());
177    if (!url.is_valid()) {
178      *error =
179          ErrorUtils::FormatErrorMessage(keys::kInvalidUrlError, url_string);
180      return NULL;
181    }
182  } else {
183    url = GURL(chrome::kChromeUINewTabURL);
184  }
185
186  // Don't let extensions crash the browser or renderers.
187  if (ExtensionTabUtil::IsCrashURL(url)) {
188    *error = keys::kNoCrashBrowserError;
189    return NULL;
190  }
191
192  // Default to foreground for the new tab. The presence of 'active' property
193  // will override this default.
194  bool active = true;
195  if (params.active.get())
196    active = *params.active;
197
198  // Default to not pinning the tab. Setting the 'pinned' property to true
199  // will override this default.
200  bool pinned = false;
201  if (params.pinned.get())
202    pinned = *params.pinned;
203
204  // We can't load extension URLs into incognito windows unless the extension
205  // uses split mode. Special case to fall back to a tabbed window.
206  if (url.SchemeIs(kExtensionScheme) &&
207      !IncognitoInfo::IsSplitMode(function->extension()) &&
208      browser->profile()->IsOffTheRecord()) {
209    Profile* profile = browser->profile()->GetOriginalProfile();
210    chrome::HostDesktopType desktop_type = browser->host_desktop_type();
211
212    browser = chrome::FindTabbedBrowser(profile, false, desktop_type);
213    if (!browser) {
214      browser = new Browser(
215          Browser::CreateParams(Browser::TYPE_TABBED, profile, desktop_type));
216      browser->window()->Show();
217    }
218  }
219
220  // If index is specified, honor the value, but keep it bound to
221  // -1 <= index <= tab_strip->count() where -1 invokes the default behavior.
222  int index = -1;
223  if (params.index.get())
224    index = *params.index;
225
226  TabStripModel* tab_strip = browser->tab_strip_model();
227
228  index = std::min(std::max(index, -1), tab_strip->count());
229
230  int add_types = active ? TabStripModel::ADD_ACTIVE : TabStripModel::ADD_NONE;
231  add_types |= TabStripModel::ADD_FORCE_INDEX;
232  if (pinned)
233    add_types |= TabStripModel::ADD_PINNED;
234  chrome::NavigateParams navigate_params(
235      browser, url, ui::PAGE_TRANSITION_LINK);
236  navigate_params.disposition =
237      active ? NEW_FOREGROUND_TAB : NEW_BACKGROUND_TAB;
238  navigate_params.tabstrip_index = index;
239  navigate_params.tabstrip_add_types = add_types;
240  chrome::Navigate(&navigate_params);
241
242  // The tab may have been created in a different window, so make sure we look
243  // at the right tab strip.
244  tab_strip = navigate_params.browser->tab_strip_model();
245  int new_index =
246      tab_strip->GetIndexOfWebContents(navigate_params.target_contents);
247  if (opener)
248    tab_strip->SetOpenerOfWebContentsAt(new_index, opener);
249
250  if (active)
251    navigate_params.target_contents->SetInitialFocus();
252
253  // Return data about the newly created tab.
254  return ExtensionTabUtil::CreateTabValue(navigate_params.target_contents,
255                                          tab_strip,
256                                          new_index,
257                                          function->extension());
258}
259
260Browser* ExtensionTabUtil::GetBrowserFromWindowID(
261    ChromeUIThreadExtensionFunction* function,
262    int window_id,
263    std::string* error) {
264  if (window_id == extension_misc::kCurrentWindowId) {
265    Browser* result = function->GetCurrentBrowser();
266    if (!result || !result->window()) {
267      if (error)
268        *error = keys::kNoCurrentWindowError;
269      return NULL;
270    }
271    return result;
272  } else {
273    return GetBrowserInProfileWithId(function->GetProfile(),
274                                     window_id,
275                                     function->include_incognito(),
276                                     error);
277  }
278}
279
280Browser* ExtensionTabUtil::GetBrowserFromWindowID(
281    const ChromeExtensionFunctionDetails& details,
282    int window_id,
283    std::string* error) {
284  if (window_id == extension_misc::kCurrentWindowId) {
285    Browser* result = details.GetCurrentBrowser();
286    if (!result || !result->window()) {
287      if (error)
288        *error = keys::kNoCurrentWindowError;
289      return NULL;
290    }
291    return result;
292  } else {
293    return GetBrowserInProfileWithId(details.GetProfile(),
294                                     window_id,
295                                     details.function()->include_incognito(),
296                                     error);
297  }
298}
299
300int ExtensionTabUtil::GetWindowId(const Browser* browser) {
301  return browser->session_id().id();
302}
303
304int ExtensionTabUtil::GetWindowIdOfTabStripModel(
305    const TabStripModel* tab_strip_model) {
306  for (chrome::BrowserIterator it; !it.done(); it.Next()) {
307    if (it->tab_strip_model() == tab_strip_model)
308      return GetWindowId(*it);
309  }
310  return -1;
311}
312
313int ExtensionTabUtil::GetTabId(const WebContents* web_contents) {
314  return SessionTabHelper::IdForTab(web_contents);
315}
316
317std::string ExtensionTabUtil::GetTabStatusText(bool is_loading) {
318  return is_loading ? keys::kStatusValueLoading : keys::kStatusValueComplete;
319}
320
321int ExtensionTabUtil::GetWindowIdOfTab(const WebContents* web_contents) {
322  return SessionTabHelper::IdForWindowContainingTab(web_contents);
323}
324
325base::DictionaryValue* ExtensionTabUtil::CreateTabValue(
326    WebContents* contents,
327    TabStripModel* tab_strip,
328    int tab_index,
329    const Extension* extension) {
330  // If we have a matching AppWindow with a controller, get the tab value
331  // from its controller instead.
332  WindowController* controller = GetAppWindowController(contents);
333  if (controller &&
334      (!extension || controller->IsVisibleToExtension(extension))) {
335    return controller->CreateTabValue(extension, tab_index);
336  }
337  base::DictionaryValue* result =
338      CreateTabValue(contents, tab_strip, tab_index);
339  ScrubTabValueForExtension(contents, extension, result);
340  return result;
341}
342
343base::ListValue* ExtensionTabUtil::CreateTabList(
344    const Browser* browser,
345    const Extension* extension) {
346  base::ListValue* tab_list = new base::ListValue();
347  TabStripModel* tab_strip = browser->tab_strip_model();
348  for (int i = 0; i < tab_strip->count(); ++i) {
349    tab_list->Append(CreateTabValue(tab_strip->GetWebContentsAt(i),
350                                    tab_strip,
351                                    i,
352                                    extension));
353  }
354
355  return tab_list;
356}
357
358base::DictionaryValue* ExtensionTabUtil::CreateTabValue(
359    WebContents* contents,
360    TabStripModel* tab_strip,
361    int tab_index) {
362  // If we have a matching AppWindow with a controller, get the tab value
363  // from its controller instead.
364  WindowController* controller = GetAppWindowController(contents);
365  if (controller)
366    return controller->CreateTabValue(NULL, tab_index);
367
368  if (!tab_strip)
369    ExtensionTabUtil::GetTabStripModel(contents, &tab_strip, &tab_index);
370
371  base::DictionaryValue* result = new base::DictionaryValue();
372  bool is_loading = contents->IsLoading();
373  result->SetInteger(keys::kIdKey, GetTabId(contents));
374  result->SetInteger(keys::kIndexKey, tab_index);
375  result->SetInteger(keys::kWindowIdKey, GetWindowIdOfTab(contents));
376  result->SetString(keys::kStatusKey, GetTabStatusText(is_loading));
377  result->SetBoolean(keys::kActiveKey,
378                     tab_strip && tab_index == tab_strip->active_index());
379  result->SetBoolean(keys::kSelectedKey,
380                     tab_strip && tab_index == tab_strip->active_index());
381  result->SetBoolean(keys::kHighlightedKey,
382                   tab_strip && tab_strip->IsTabSelected(tab_index));
383  result->SetBoolean(keys::kPinnedKey,
384                     tab_strip && tab_strip->IsTabPinned(tab_index));
385  result->SetBoolean(keys::kIncognitoKey,
386                     contents->GetBrowserContext()->IsOffTheRecord());
387  result->SetInteger(keys::kWidthKey,
388                     contents->GetContainerBounds().size().width());
389  result->SetInteger(keys::kHeightKey,
390                     contents->GetContainerBounds().size().height());
391
392  // Privacy-sensitive fields: these should be stripped off by
393  // ScrubTabValueForExtension if the extension should not see them.
394  result->SetString(keys::kUrlKey, contents->GetURL().spec());
395  result->SetString(keys::kTitleKey, contents->GetTitle());
396  if (!is_loading) {
397    NavigationEntry* entry = contents->GetController().GetVisibleEntry();
398    if (entry && entry->GetFavicon().valid)
399      result->SetString(keys::kFaviconUrlKey, entry->GetFavicon().url.spec());
400  }
401
402  if (tab_strip) {
403    WebContents* opener = tab_strip->GetOpenerOfWebContentsAt(tab_index);
404    if (opener)
405      result->SetInteger(keys::kOpenerTabIdKey, GetTabId(opener));
406  }
407
408  return result;
409}
410
411void ExtensionTabUtil::ScrubTabValueForExtension(
412    WebContents* contents,
413    const Extension* extension,
414    base::DictionaryValue* tab_info) {
415  bool has_permission = extension &&
416                        extension->permissions_data()->HasAPIPermissionForTab(
417                            GetTabId(contents), APIPermission::kTab);
418
419  if (!has_permission) {
420    tab_info->Remove(keys::kUrlKey, NULL);
421    tab_info->Remove(keys::kTitleKey, NULL);
422    tab_info->Remove(keys::kFaviconUrlKey, NULL);
423  }
424}
425
426void ExtensionTabUtil::ScrubTabForExtension(const Extension* extension,
427                                            api::tabs::Tab* tab) {
428  bool has_permission =
429      extension &&
430      extension->permissions_data()->HasAPIPermission(APIPermission::kTab);
431
432  if (!has_permission) {
433    tab->url.reset();
434    tab->title.reset();
435    tab->fav_icon_url.reset();
436  }
437}
438
439bool ExtensionTabUtil::GetTabStripModel(const WebContents* web_contents,
440                                        TabStripModel** tab_strip_model,
441                                        int* tab_index) {
442  DCHECK(web_contents);
443  DCHECK(tab_strip_model);
444  DCHECK(tab_index);
445
446  for (chrome::BrowserIterator it; !it.done(); it.Next()) {
447    TabStripModel* tab_strip = it->tab_strip_model();
448    int index = tab_strip->GetIndexOfWebContents(web_contents);
449    if (index != -1) {
450      *tab_strip_model = tab_strip;
451      *tab_index = index;
452      return true;
453    }
454  }
455
456  return false;
457}
458
459bool ExtensionTabUtil::GetDefaultTab(Browser* browser,
460                                     WebContents** contents,
461                                     int* tab_id) {
462  DCHECK(browser);
463  DCHECK(contents);
464
465  *contents = browser->tab_strip_model()->GetActiveWebContents();
466  if (*contents) {
467    if (tab_id)
468      *tab_id = GetTabId(*contents);
469    return true;
470  }
471
472  return false;
473}
474
475bool ExtensionTabUtil::GetTabById(int tab_id,
476                                  content::BrowserContext* browser_context,
477                                  bool include_incognito,
478                                  Browser** browser,
479                                  TabStripModel** tab_strip,
480                                  WebContents** contents,
481                                  int* tab_index) {
482  Profile* profile = Profile::FromBrowserContext(browser_context);
483  Profile* incognito_profile =
484      include_incognito && profile->HasOffTheRecordProfile() ?
485          profile->GetOffTheRecordProfile() : NULL;
486  for (chrome::BrowserIterator it; !it.done(); it.Next()) {
487    Browser* target_browser = *it;
488    if (target_browser->profile() == profile ||
489        target_browser->profile() == incognito_profile) {
490      TabStripModel* target_tab_strip = target_browser->tab_strip_model();
491      for (int i = 0; i < target_tab_strip->count(); ++i) {
492        WebContents* target_contents = target_tab_strip->GetWebContentsAt(i);
493        if (SessionTabHelper::IdForTab(target_contents) == tab_id) {
494          if (browser)
495            *browser = target_browser;
496          if (tab_strip)
497            *tab_strip = target_tab_strip;
498          if (contents)
499            *contents = target_contents;
500          if (tab_index)
501            *tab_index = i;
502          return true;
503        }
504      }
505    }
506  }
507  return false;
508}
509
510GURL ExtensionTabUtil::ResolvePossiblyRelativeURL(const std::string& url_string,
511                                                  const Extension* extension) {
512  GURL url = GURL(url_string);
513  if (!url.is_valid())
514    url = extension->GetResourceURL(url_string);
515
516  return url;
517}
518
519bool ExtensionTabUtil::IsCrashURL(const GURL& url) {
520  // Check a fixed-up URL, to normalize the scheme and parse hosts correctly.
521  GURL fixed_url =
522      url_fixer::FixupURL(url.possibly_invalid_spec(), std::string());
523  return (fixed_url.SchemeIs(content::kChromeUIScheme) &&
524          (fixed_url.host() == content::kChromeUIBrowserCrashHost ||
525           fixed_url.host() == chrome::kChromeUICrashHost));
526}
527
528void ExtensionTabUtil::CreateTab(WebContents* web_contents,
529                                 const std::string& extension_id,
530                                 WindowOpenDisposition disposition,
531                                 const gfx::Rect& initial_pos,
532                                 bool user_gesture) {
533  Profile* profile =
534      Profile::FromBrowserContext(web_contents->GetBrowserContext());
535  chrome::HostDesktopType active_desktop = chrome::GetActiveDesktop();
536  Browser* browser = chrome::FindTabbedBrowser(profile, false, active_desktop);
537  const bool browser_created = !browser;
538  if (!browser)
539    browser = new Browser(Browser::CreateParams(profile, active_desktop));
540  chrome::NavigateParams params(browser, web_contents);
541
542  // The extension_app_id parameter ends up as app_name in the Browser
543  // which causes the Browser to return true for is_app().  This affects
544  // among other things, whether the location bar gets displayed.
545  // TODO(mpcomplete): This seems wrong. What if the extension content is hosted
546  // in a tab?
547  if (disposition == NEW_POPUP)
548    params.extension_app_id = extension_id;
549
550  params.disposition = disposition;
551  params.window_bounds = initial_pos;
552  params.window_action = chrome::NavigateParams::SHOW_WINDOW;
553  params.user_gesture = user_gesture;
554  chrome::Navigate(&params);
555
556  // Close the browser if chrome::Navigate created a new one.
557  if (browser_created && (browser != params.browser))
558    browser->window()->Close();
559}
560
561// static
562void ExtensionTabUtil::ForEachTab(
563    const base::Callback<void(WebContents*)>& callback) {
564  for (TabContentsIterator iterator; !iterator.done(); iterator.Next())
565    callback.Run(*iterator);
566}
567
568// static
569WindowController* ExtensionTabUtil::GetWindowControllerOfTab(
570    const WebContents* web_contents) {
571  Browser* browser = chrome::FindBrowserWithWebContents(web_contents);
572  if (browser != NULL)
573    return browser->extension_window_controller();
574
575  return NULL;
576}
577
578void ExtensionTabUtil::OpenOptionsPage(const Extension* extension,
579                                       Browser* browser) {
580  DCHECK(OptionsPageInfo::HasOptionsPage(extension));
581
582  // Force the options page to open in non-OTR window, because it won't be
583  // able to save settings from OTR.
584  scoped_ptr<chrome::ScopedTabbedBrowserDisplayer> displayer;
585  if (browser->profile()->IsOffTheRecord()) {
586    displayer.reset(new chrome::ScopedTabbedBrowserDisplayer(
587        browser->profile()->GetOriginalProfile(),
588        browser->host_desktop_type()));
589    browser = displayer->browser();
590  }
591
592  if (!OptionsPageInfo::ShouldOpenInTab(extension)) {
593    // If we should embed the options page for this extension, open
594    // chrome://extensions in a new tab and show the extension options in an
595    // embedded popup.
596    chrome::NavigateParams params(chrome::GetSingletonTabNavigateParams(
597        browser, GURL(chrome::kChromeUIExtensionsURL)));
598    params.path_behavior = chrome::NavigateParams::IGNORE_AND_NAVIGATE;
599
600    GURL::Replacements replacements;
601    std::string query =
602        base::StringPrintf("options=%s", extension->id().c_str());
603    replacements.SetQueryStr(query);
604    params.url = params.url.ReplaceComponents(replacements);
605
606    chrome::ShowSingletonTabOverwritingNTP(browser, params);
607  } else {
608    // Otherwise open a new tab with the extension's options page
609    content::OpenURLParams params(OptionsPageInfo::GetOptionsPage(extension),
610                                  content::Referrer(),
611                                  SINGLETON_TAB,
612                                  ui::PAGE_TRANSITION_LINK,
613                                  false);
614    browser->OpenURL(params);
615    browser->window()->Show();
616    WebContents* web_contents =
617        browser->tab_strip_model()->GetActiveWebContents();
618    web_contents->GetDelegate()->ActivateContents(web_contents);
619  }
620}
621
622}  // namespace extensions
623