chrome/browser/extensions/extension_tab_util.cc

   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 "chrome/browser/extensions/api/tabs/tabs_constants.h"
   8 #include "chrome/browser/extensions/shell_window_registry.h"
   9 #include "chrome/browser/extensions/tab_helper.h"
  10 #include "chrome/browser/extensions/window_controller.h"
  11 #include "chrome/browser/extensions/window_controller_list.h"
  12 #include "chrome/browser/net/url_fixer_upper.h"
  13 #include "chrome/browser/profiles/profile.h"
  14 #include "chrome/browser/sessions/session_id.h"
  15 #include "chrome/browser/ui/browser.h"
  16 #include "chrome/browser/ui/browser_finder.h"
  17 #include "chrome/browser/ui/browser_iterator.h"
  18 #include "chrome/browser/ui/browser_window.h"
  19 #include "chrome/browser/ui/extensions/shell_window.h"
  20 #include "chrome/browser/ui/tab_contents/tab_contents_iterator.h"
  21 #include "chrome/browser/ui/tabs/tab_strip_model.h"
  22 #include "chrome/common/extensions/extension.h"
  23 #include "chrome/common/extensions/extension_manifest_constants.h"
  24 #include "chrome/common/extensions/manifest_url_handler.h"
  25 #include "chrome/common/extensions/permissions/api_permission.h"
  26 #include "chrome/common/extensions/permissions/permissions_data.h"
  27 #include "chrome/common/url_constants.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 "googleurl/src/gurl.h"
  32
  33 namespace keys = extensions::tabs_constants;
  34 namespace tabs = extensions::api::tabs;
  35
  36 using content::NavigationEntry;
  37 using content::WebContents;
  38 using extensions::APIPermission;
  39 using extensions::Extension;
  40
  41 namespace {
  42
  43 extensions::WindowController* GetShellWindowController(
  44     const WebContents* contents) {
  45   Profile* profile = Profile::FromBrowserContext(contents->GetBrowserContext());
  46   extensions::ShellWindowRegistry* registry =
  47       extensions::ShellWindowRegistry::Get(profile);
  48   if (!registry)
  49     return NULL;
  50   ShellWindow* shell_window =
  51       registry->GetShellWindowForRenderViewHost(contents->GetRenderViewHost());
  52   if (!shell_window)
  53     return NULL;
  54   return extensions::WindowControllerList::GetInstance()->
  55       FindWindowById(shell_window->session_id().id());
  56 }
  57
  58 }  // namespace
  59
  60 int ExtensionTabUtil::GetWindowId(const Browser* browser) {
  61   return browser->session_id().id();
  62 }
  63
  64 int ExtensionTabUtil::GetWindowIdOfTabStripModel(
  65     const TabStripModel* tab_strip_model) {
  66   for (chrome::BrowserIterator it; !it.done(); it.Next()) {
  67     if (it->tab_strip_model() == tab_strip_model)
  68       return GetWindowId(*it);
  69   }
  70   return -1;
  71 }
  72
  73 int ExtensionTabUtil::GetTabId(const WebContents* web_contents) {
  74   return SessionID::IdForTab(web_contents);
  75 }
  76
  77 std::string ExtensionTabUtil::GetTabStatusText(bool is_loading) {
  78   return is_loading ? keys::kStatusValueLoading : keys::kStatusValueComplete;
  79 }
  80
  81 int ExtensionTabUtil::GetWindowIdOfTab(const WebContents* web_contents) {
  82   return SessionID::IdForWindowContainingTab(web_contents);
  83 }
  84
  85 DictionaryValue* ExtensionTabUtil::CreateTabValue(
  86     const WebContents* contents,
  87     TabStripModel* tab_strip,
  88     int tab_index,
  89     const Extension* extension) {
  90   // If we have a matching ShellWindow with a controller, get the tab value
  91   // from its controller instead.
  92   extensions::WindowController* controller = GetShellWindowController(contents);
  93   if (controller &&
  94       (!extension || controller->IsVisibleToExtension(extension))) {
  95     return controller->CreateTabValue(extension, tab_index);
  96   }
  97   DictionaryValue *result = CreateTabValue(contents, tab_strip, tab_index);
  98   ScrubTabValueForExtension(contents, extension, result);
  99   return result;
 100 }
 101
 102 ListValue* ExtensionTabUtil::CreateTabList(
 103     const Browser* browser,
 104     const Extension* extension) {
 105   ListValue* tab_list = new ListValue();
 106   TabStripModel* tab_strip = browser->tab_strip_model();
 107   for (int i = 0; i < tab_strip->count(); ++i) {
 108     tab_list->Append(CreateTabValue(tab_strip->GetWebContentsAt(i),
 109                                     tab_strip,
 110                                     i,
 111                                     extension));
 112   }
 113
 114   return tab_list;
 115 }
 116
 117 DictionaryValue* ExtensionTabUtil::CreateTabValue(
 118     const WebContents* contents,
 119     TabStripModel* tab_strip,
 120     int tab_index) {
 121   // If we have a matching ShellWindow with a controller, get the tab value
 122   // from its controller instead.
 123   extensions::WindowController* controller = GetShellWindowController(contents);
 124   if (controller)
 125     return controller->CreateTabValue(NULL, tab_index);
 126
 127   if (!tab_strip)
 128     ExtensionTabUtil::GetTabStripModel(contents, &tab_strip, &tab_index);
 129
 130   DictionaryValue* result = new DictionaryValue();
 131   bool is_loading = contents->IsLoading();
 132   result->SetInteger(keys::kIdKey, GetTabId(contents));
 133   result->SetInteger(keys::kIndexKey, tab_index);
 134   result->SetInteger(keys::kWindowIdKey, GetWindowIdOfTab(contents));
 135   result->SetString(keys::kStatusKey, GetTabStatusText(is_loading));
 136   result->SetBoolean(keys::kActiveKey,
 137                      tab_strip && tab_index == tab_strip->active_index());
 138   result->SetBoolean(keys::kSelectedKey,
 139                      tab_strip && tab_index == tab_strip->active_index());
 140   result->SetBoolean(keys::kHighlightedKey,
 141                    tab_strip && tab_strip->IsTabSelected(tab_index));
 142   result->SetBoolean(keys::kPinnedKey,
 143                      tab_strip && tab_strip->IsTabPinned(tab_index));
 144   result->SetBoolean(keys::kIncognitoKey,
 145                      contents->GetBrowserContext()->IsOffTheRecord());
 146
 147   // Privacy-sensitive fields: these should be stripped off by
 148   // ScrubTabValueForExtension if the extension should not see them.
 149   result->SetString(keys::kUrlKey, contents->GetURL().spec());
 150   result->SetString(keys::kTitleKey, contents->GetTitle());
 151   if (!is_loading) {
 152     NavigationEntry* entry = contents->GetController().GetActiveEntry();
 153     if (entry && entry->GetFavicon().valid)
 154       result->SetString(keys::kFaviconUrlKey, entry->GetFavicon().url.spec());
 155   }
 156
 157   if (tab_strip) {
 158     WebContents* opener = tab_strip->GetOpenerOfWebContentsAt(tab_index);
 159     if (opener)
 160       result->SetInteger(keys::kOpenerTabIdKey, GetTabId(opener));
 161   }
 162
 163   return result;
 164 }
 165
 166 void ExtensionTabUtil::ScrubTabValueForExtension(const WebContents* contents,
 167                                                  const Extension* extension,
 168                                                  DictionaryValue* tab_info) {
 169   bool has_permission =
 170       extension &&
 171       extensions::PermissionsData::HasAPIPermissionForTab(
 172           extension, GetTabId(contents), APIPermission::kTab);
 173
 174   if (!has_permission) {
 175     tab_info->Remove(keys::kUrlKey, NULL);
 176     tab_info->Remove(keys::kTitleKey, NULL);
 177     tab_info->Remove(keys::kFaviconUrlKey, NULL);
 178   }
 179 }
 180
 181 void ExtensionTabUtil::ScrubTabForExtension(const Extension* extension,
 182                                             tabs::Tab* tab) {
 183   bool has_permission = extension && extension->HasAPIPermission(
 184       APIPermission::kTab);
 185
 186   if (!has_permission) {
 187     tab->url.reset();
 188     tab->title.reset();
 189     tab->fav_icon_url.reset();
 190   }
 191 }
 192
 193 bool ExtensionTabUtil::GetTabStripModel(const WebContents* web_contents,
 194                                         TabStripModel** tab_strip_model,
 195                                         int* tab_index) {
 196   DCHECK(web_contents);
 197   DCHECK(tab_strip_model);
 198   DCHECK(tab_index);
 199
 200   for (chrome::BrowserIterator it; !it.done(); it.Next()) {
 201     TabStripModel* tab_strip = it->tab_strip_model();
 202     int index = tab_strip->GetIndexOfWebContents(web_contents);
 203     if (index != -1) {
 204       *tab_strip_model = tab_strip;
 205       *tab_index = index;
 206       return true;
 207     }
 208   }
 209
 210   return false;
 211 }
 212
 213 bool ExtensionTabUtil::GetDefaultTab(Browser* browser,
 214                                      WebContents** contents,
 215                                      int* tab_id) {
 216   DCHECK(browser);
 217   DCHECK(contents);
 218
 219   *contents = browser->tab_strip_model()->GetActiveWebContents();
 220   if (*contents) {
 221     if (tab_id)
 222       *tab_id = GetTabId(*contents);
 223     return true;
 224   }
 225
 226   return false;
 227 }
 228
 229 bool ExtensionTabUtil::GetTabById(int tab_id,
 230                                   Profile* profile,
 231                                   bool include_incognito,
 232                                   Browser** browser,
 233                                   TabStripModel** tab_strip,
 234                                   WebContents** contents,
 235                                   int* tab_index) {
 236   Profile* incognito_profile =
 237       include_incognito && profile->HasOffTheRecordProfile() ?
 238           profile->GetOffTheRecordProfile() : NULL;
 239   for (chrome::BrowserIterator it; !it.done(); it.Next()) {
 240     Browser* target_browser = *it;
 241     if (target_browser->profile() == profile ||
 242         target_browser->profile() == incognito_profile) {
 243       TabStripModel* target_tab_strip = target_browser->tab_strip_model();
 244       for (int i = 0; i < target_tab_strip->count(); ++i) {
 245         WebContents* target_contents = target_tab_strip->GetWebContentsAt(i);
 246         if (SessionID::IdForTab(target_contents) == tab_id) {
 247           if (browser)
 248             *browser = target_browser;
 249           if (tab_strip)
 250             *tab_strip = target_tab_strip;
 251           if (contents)
 252             *contents = target_contents;
 253           if (tab_index)
 254             *tab_index = i;
 255           return true;
 256         }
 257       }
 258     }
 259   }
 260   return false;
 261 }
 262
 263 GURL ExtensionTabUtil::ResolvePossiblyRelativeURL(const std::string& url_string,
 264     const extensions::Extension* extension) {
 265   GURL url = GURL(url_string);
 266   if (!url.is_valid())
 267     url = extension->GetResourceURL(url_string);
 268
 269   return url;
 270 }
 271
 272 bool ExtensionTabUtil::IsCrashURL(const GURL& url) {
 273   // Check a fixed-up URL, to normalize the scheme and parse hosts correctly.
 274   GURL fixed_url =
 275       URLFixerUpper::FixupURL(url.possibly_invalid_spec(), std::string());
 276   return (fixed_url.SchemeIs(chrome::kChromeUIScheme) &&
 277           (fixed_url.host() == content::kChromeUIBrowserCrashHost ||
 278            fixed_url.host() == chrome::kChromeUICrashHost));
 279 }
 280
 281 void ExtensionTabUtil::CreateTab(WebContents* web_contents,
 282                                  const std::string& extension_id,
 283                                  WindowOpenDisposition disposition,
 284                                  const gfx::Rect& initial_pos,
 285                                  bool user_gesture) {
 286   Profile* profile =
 287       Profile::FromBrowserContext(web_contents->GetBrowserContext());
 288   chrome::HostDesktopType active_desktop = chrome::GetActiveDesktop();
 289   Browser* browser = chrome::FindTabbedBrowser(profile, false, active_desktop);
 290   const bool browser_created = !browser;
 291   if (!browser)
 292     browser = new Browser(Browser::CreateParams(profile, active_desktop));
 293   chrome::NavigateParams params(browser, web_contents);
 294
 295   // The extension_app_id parameter ends up as app_name in the Browser
 296   // which causes the Browser to return true for is_app().  This affects
 297   // among other things, whether the location bar gets displayed.
 298   // TODO(mpcomplete): This seems wrong. What if the extension content is hosted
 299   // in a tab?
 300   if (disposition == NEW_POPUP)
 301     params.extension_app_id = extension_id;
 302
 303   params.disposition = disposition;
 304   params.window_bounds = initial_pos;
 305   params.window_action = chrome::NavigateParams::SHOW_WINDOW;
 306   params.user_gesture = user_gesture;
 307   chrome::Navigate(&params);
 308
 309   // Close the browser if chrome::Navigate created a new one.
 310   if (browser_created && (browser != params.browser))
 311     browser->window()->Close();
 312 }
 313
 314 // static
 315 void ExtensionTabUtil::ForEachTab(
 316     const base::Callback<void(WebContents*)>& callback) {
 317   for (TabContentsIterator iterator; !iterator.done(); iterator.Next())
 318     callback.Run(*iterator);
 319 }
 320
 321 // static
 322 extensions::WindowController* ExtensionTabUtil::GetWindowControllerOfTab(
 323     const WebContents* web_contents) {
 324   Browser* browser = chrome::FindBrowserWithWebContents(web_contents);
 325   if (browser != NULL)
 326     return browser->extension_window_controller();
 327
 328   return NULL;
 329 }
 330
 331 void ExtensionTabUtil::OpenOptionsPage(const Extension* extension,
 332                                        Browser* browser) {
 333   DCHECK(!extensions::ManifestURL::GetOptionsPage(extension).is_empty());
 334
 335   // Force the options page to open in non-OTR window, because it won't be
 336   // able to save settings from OTR.
 337   if (browser->profile()->IsOffTheRecord()) {
 338     browser = chrome::FindOrCreateTabbedBrowser(
 339         browser->profile()->GetOriginalProfile(), browser->host_desktop_type());
 340   }
 341
 342   content::OpenURLParams params(
 343       extensions::ManifestURL::GetOptionsPage(extension),
 344       content::Referrer(), SINGLETON_TAB,
 345       content::PAGE_TRANSITION_LINK, false);
 346   browser->OpenURL(params);
 347   browser->window()->Show();
 348   WebContents* web_contents =
 349       browser->tab_strip_model()->GetActiveWebContents();
 350   web_contents->GetDelegate()->ActivateContents(web_contents);
 351 }