chrome/browser/extensions/chrome_content_browser_client_extensions_part.cc

   1 // Copyright 2014 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/chrome_content_browser_client_extensions_part.h"
   6
   7 #include <set>
   8
   9 #include "base/command_line.h"
  10 #include "chrome/browser/browser_process.h"
  11 #include "chrome/browser/extensions/browser_permissions_policy_delegate.h"
  12 #include "chrome/browser/extensions/extension_service.h"
  13 #include "chrome/browser/extensions/extension_web_ui.h"
  14 #include "chrome/browser/extensions/extension_webkit_preferences.h"
  15 #include "chrome/browser/media_galleries/fileapi/media_file_system_backend.h"
  16 #include "chrome/browser/profiles/profile.h"
  17 #include "chrome/browser/profiles/profile_io_data.h"
  18 #include "chrome/browser/profiles/profile_manager.h"
  19 #include "chrome/browser/renderer_host/chrome_extension_message_filter.h"
  20 #include "chrome/browser/sync_file_system/local/sync_file_system_backend.h"
  21 #include "chrome/common/chrome_constants.h"
  22 #include "chrome/common/extensions/extension_process_policy.h"
  23 #include "chrome/common/extensions/manifest_handlers/app_isolation_info.h"
  24 #include "content/public/browser/browser_thread.h"
  25 #include "content/public/browser/browser_url_handler.h"
  26 #include "content/public/browser/render_process_host.h"
  27 #include "content/public/browser/render_view_host.h"
  28 #include "content/public/browser/site_instance.h"
  29 #include "content/public/browser/web_contents.h"
  30 #include "content/public/common/content_switches.h"
  31 #include "extensions/browser/api/web_request/web_request_api.h"
  32 #include "extensions/browser/api/web_request/web_request_api_helpers.h"
  33 #include "extensions/browser/extension_host.h"
  34 #include "extensions/browser/extension_message_filter.h"
  35 #include "extensions/browser/extension_registry.h"
  36 #include "extensions/browser/extension_system.h"
  37 #include "extensions/browser/info_map.h"
  38 #include "extensions/browser/view_type_utils.h"
  39 #include "extensions/common/constants.h"
  40 #include "extensions/common/manifest_handlers/background_info.h"
  41 #include "extensions/common/manifest_handlers/web_accessible_resources_info.h"
  42 #include "extensions/common/switches.h"
  43
  44 using content::BrowserThread;
  45 using content::BrowserURLHandler;
  46 using content::RenderViewHost;
  47 using content::SiteInstance;
  48 using content::WebContents;
  49 using content::WebPreferences;
  50
  51 namespace extensions {
  52
  53 namespace {
  54
  55 // Used by the GetPrivilegeRequiredByUrl() and GetProcessPrivilege() functions
  56 // below.  Extension, and isolated apps require different privileges to be
  57 // granted to their RenderProcessHosts.  This classification allows us to make
  58 // sure URLs are served by hosts with the right set of privileges.
  59 enum RenderProcessHostPrivilege {
  60   PRIV_NORMAL,
  61   PRIV_HOSTED,
  62   PRIV_ISOLATED,
  63   PRIV_EXTENSION,
  64 };
  65
  66 RenderProcessHostPrivilege GetPrivilegeRequiredByUrl(
  67     const GURL& url,
  68     ExtensionService* service) {
  69   // Default to a normal renderer cause it is lower privileged. This should only
  70   // occur if the URL on a site instance is either malformed, or uninitialized.
  71   // If it is malformed, then there is no need for better privileges anyways.
  72   // If it is uninitialized, but eventually settles on being an a scheme other
  73   // than normal webrenderer, the navigation logic will correct us out of band
  74   // anyways.
  75   if (!url.is_valid())
  76     return PRIV_NORMAL;
  77
  78   if (!url.SchemeIs(kExtensionScheme))
  79     return PRIV_NORMAL;
  80
  81   const Extension* extension = service->extensions()->GetByID(url.host());
  82   if (extension && AppIsolationInfo::HasIsolatedStorage(extension))
  83     return PRIV_ISOLATED;
  84   if (extension && extension->is_hosted_app())
  85     return PRIV_HOSTED;
  86   return PRIV_EXTENSION;
  87 }
  88
  89 RenderProcessHostPrivilege GetProcessPrivilege(
  90     content::RenderProcessHost* process_host,
  91     ProcessMap* process_map,
  92     ExtensionService* service) {
  93   std::set<std::string> extension_ids =
  94       process_map->GetExtensionsInProcess(process_host->GetID());
  95   if (extension_ids.empty())
  96     return PRIV_NORMAL;
  97
  98   for (std::set<std::string>::iterator iter = extension_ids.begin();
  99        iter != extension_ids.end(); ++iter) {
 100     const Extension* extension = service->GetExtensionById(*iter, false);
 101     if (extension && AppIsolationInfo::HasIsolatedStorage(extension))
 102       return PRIV_ISOLATED;
 103     if (extension && extension->is_hosted_app())
 104       return PRIV_HOSTED;
 105   }
 106
 107   return PRIV_EXTENSION;
 108 }
 109
 110 }  // namespace
 111
 112 ChromeContentBrowserClientExtensionsPart::
 113     ChromeContentBrowserClientExtensionsPart() {
 114   permissions_policy_delegate_.reset(new BrowserPermissionsPolicyDelegate());
 115 }
 116
 117 ChromeContentBrowserClientExtensionsPart::
 118     ~ChromeContentBrowserClientExtensionsPart() {
 119 }
 120
 121 // static
 122 GURL ChromeContentBrowserClientExtensionsPart::GetEffectiveURL(
 123     Profile* profile, const GURL& url) {
 124   // If the input |url| is part of an installed app, the effective URL is an
 125   // extension URL with the ID of that extension as the host. This has the
 126   // effect of grouping apps together in a common SiteInstance.
 127   ExtensionService* extension_service =
 128       ExtensionSystem::Get(profile)->extension_service();
 129   if (!extension_service)
 130     return url;
 131
 132   const Extension* extension =
 133       extension_service->extensions()->GetHostedAppByURL(url);
 134   if (!extension)
 135     return url;
 136
 137   // Bookmark apps do not use the hosted app process model, and should be
 138   // treated as normal URLs.
 139   if (extension->from_bookmark())
 140     return url;
 141
 142   // If the URL is part of an extension's web extent, convert it to an
 143   // extension URL.
 144   return extension->GetResourceURL(url.path());
 145 }
 146
 147 // static
 148 bool ChromeContentBrowserClientExtensionsPart::ShouldUseProcessPerSite(
 149     Profile* profile, const GURL& effective_url) {
 150   if (!effective_url.SchemeIs(kExtensionScheme))
 151     return false;
 152
 153   ExtensionService* extension_service =
 154       ExtensionSystem::Get(profile)->extension_service();
 155   if (!extension_service)
 156     return false;
 157
 158   const Extension* extension =
 159       extension_service->extensions()->GetExtensionOrAppByURL(effective_url);
 160   if (!extension)
 161     return false;
 162
 163   // If the URL is part of a hosted app that does not have the background
 164   // permission, or that does not allow JavaScript access to the background
 165   // page, we want to give each instance its own process to improve
 166   // responsiveness.
 167   if (extension->GetType() == Manifest::TYPE_HOSTED_APP) {
 168     if (!extension->permissions_data()->HasAPIPermission(
 169             APIPermission::kBackground) ||
 170         !BackgroundInfo::AllowJSAccess(extension)) {
 171       return false;
 172     }
 173   }
 174
 175   // Hosted apps that have script access to their background page must use
 176   // process per site, since all instances can make synchronous calls to the
 177   // background window.  Other extensions should use process per site as well.
 178   return true;
 179 }
 180
 181 // static
 182 bool ChromeContentBrowserClientExtensionsPart::CanCommitURL(
 183     content::RenderProcessHost* process_host, const GURL& url) {
 184   // We need to let most extension URLs commit in any process, since this can
 185   // be allowed due to web_accessible_resources.  Most hosted app URLs may also
 186   // load in any process (e.g., in an iframe).  However, the Chrome Web Store
 187   // cannot be loaded in iframes and should never be requested outside its
 188   // process.
 189   Profile* profile =
 190       Profile::FromBrowserContext(process_host->GetBrowserContext());
 191   ExtensionService* service =
 192       ExtensionSystem::Get(profile)->extension_service();
 193   if (!service)
 194     return true;
 195
 196   const Extension* new_extension =
 197       service->extensions()->GetExtensionOrAppByURL(url);
 198   if (new_extension &&
 199       new_extension->is_hosted_app() &&
 200       new_extension->id() == extensions::kWebStoreAppId &&
 201       !ProcessMap::Get(profile)->Contains(
 202           new_extension->id(), process_host->GetID())) {
 203     return false;
 204   }
 205   return true;
 206 }
 207
 208 // static
 209 bool ChromeContentBrowserClientExtensionsPart::IsSuitableHost(
 210     Profile* profile,
 211     content::RenderProcessHost* process_host,
 212     const GURL& site_url) {
 213   DCHECK(profile);
 214
 215   ExtensionService* service =
 216       ExtensionSystem::Get(profile)->extension_service();
 217   ProcessMap* process_map = ProcessMap::Get(profile);
 218
 219   // These may be NULL during tests. In that case, just assume any site can
 220   // share any host.
 221   if (!service || !process_map)
 222     return true;
 223
 224   // Otherwise, just make sure the process privilege matches the privilege
 225   // required by the site.
 226   RenderProcessHostPrivilege privilege_required =
 227       GetPrivilegeRequiredByUrl(site_url, service);
 228   return GetProcessPrivilege(process_host, process_map, service) ==
 229       privilege_required;
 230 }
 231
 232 // static
 233 bool
 234 ChromeContentBrowserClientExtensionsPart::ShouldTryToUseExistingProcessHost(
 235     Profile* profile, const GURL& url) {
 236   // This function is trying to limit the amount of processes used by extensions
 237   // with background pages. It uses a globally set percentage of processes to
 238   // run such extensions and if the limit is exceeded, it returns true, to
 239   // indicate to the content module to group extensions together.
 240   ExtensionService* service = profile ?
 241       ExtensionSystem::Get(profile)->extension_service() : NULL;
 242   if (!service)
 243     return false;
 244
 245   // We have to have a valid extension with background page to proceed.
 246   const Extension* extension =
 247       service->extensions()->GetExtensionOrAppByURL(url);
 248   if (!extension)
 249     return false;
 250   if (!BackgroundInfo::HasBackgroundPage(extension))
 251     return false;
 252
 253   std::set<int> process_ids;
 254   size_t max_process_count =
 255       content::RenderProcessHost::GetMaxRendererProcessCount();
 256
 257   // Go through all profiles to ensure we have total count of extension
 258   // processes containing background pages, otherwise one profile can
 259   // starve the other.
 260   std::vector<Profile*> profiles = g_browser_process->profile_manager()->
 261       GetLoadedProfiles();
 262   for (size_t i = 0; i < profiles.size(); ++i) {
 263     ProcessManager* epm = ExtensionSystem::Get(profiles[i])->process_manager();
 264     for (ProcessManager::const_iterator iter = epm->background_hosts().begin();
 265          iter != epm->background_hosts().end(); ++iter) {
 266       const ExtensionHost* host = *iter;
 267       process_ids.insert(host->render_process_host()->GetID());
 268     }
 269   }
 270
 271   return (process_ids.size() >
 272           (max_process_count * chrome::kMaxShareOfExtensionProcesses));
 273 }
 274
 275 // static
 276 bool ChromeContentBrowserClientExtensionsPart::
 277     ShouldSwapBrowsingInstancesForNavigation(SiteInstance* site_instance,
 278                                              const GURL& current_url,
 279                                              const GURL& new_url) {
 280   // If we don't have an ExtensionService, then rely on the SiteInstance logic
 281   // in RenderFrameHostManager to decide when to swap.
 282   Profile* profile =
 283       Profile::FromBrowserContext(site_instance->GetBrowserContext());
 284   ExtensionService* service =
 285       ExtensionSystem::Get(profile)->extension_service();
 286   if (!service)
 287     return false;
 288
 289   // We must use a new BrowsingInstance (forcing a process swap and disabling
 290   // scripting by existing tabs) if one of the URLs is an extension and the
 291   // other is not the exact same extension.
 292   //
 293   // We ignore hosted apps here so that other tabs in their BrowsingInstance can
 294   // use postMessage with them.  (The exception is the Chrome Web Store, which
 295   // is a hosted app that requires its own BrowsingInstance.)  Navigations
 296   // to/from a hosted app will still trigger a SiteInstance swap in
 297   // RenderFrameHostManager.
 298   const Extension* current_extension =
 299       service->extensions()->GetExtensionOrAppByURL(current_url);
 300   if (current_extension &&
 301       current_extension->is_hosted_app() &&
 302       current_extension->id() != extensions::kWebStoreAppId)
 303     current_extension = NULL;
 304
 305   const Extension* new_extension =
 306       service->extensions()->GetExtensionOrAppByURL(new_url);
 307   if (new_extension &&
 308       new_extension->is_hosted_app() &&
 309       new_extension->id() != extensions::kWebStoreAppId)
 310     new_extension = NULL;
 311
 312   // First do a process check.  We should force a BrowsingInstance swap if the
 313   // current process doesn't know about new_extension, even if current_extension
 314   // is somehow the same as new_extension.
 315   ProcessMap* process_map = ProcessMap::Get(profile);
 316   if (new_extension &&
 317       site_instance->HasProcess() &&
 318       !process_map->Contains(
 319           new_extension->id(), site_instance->GetProcess()->GetID()))
 320     return true;
 321
 322   // Otherwise, swap BrowsingInstances if current_extension and new_extension
 323   // differ.
 324   return current_extension != new_extension;
 325 }
 326
 327 // static
 328 bool ChromeContentBrowserClientExtensionsPart::ShouldSwapProcessesForRedirect(
 329     content::ResourceContext* resource_context,
 330     const GURL& current_url,
 331     const GURL& new_url) {
 332   ProfileIOData* io_data = ProfileIOData::FromResourceContext(resource_context);
 333   return CrossesExtensionProcessBoundary(
 334       io_data->GetExtensionInfoMap()->extensions(),
 335       current_url, new_url, false);
 336 }
 337
 338 // static
 339 bool ChromeContentBrowserClientExtensionsPart::ShouldAllowOpenURL(
 340     content::SiteInstance* site_instance,
 341     const GURL& from_url,
 342     const GURL& to_url,
 343     bool* result) {
 344   DCHECK(result);
 345
 346   // Do not allow pages from the web or other extensions navigate to
 347   // non-web-accessible extension resources.
 348   if (to_url.SchemeIs(kExtensionScheme) &&
 349       (from_url.SchemeIsHTTPOrHTTPS() || from_url.SchemeIs(kExtensionScheme))) {
 350     Profile* profile = Profile::FromBrowserContext(
 351         site_instance->GetProcess()->GetBrowserContext());
 352     ExtensionService* service =
 353         ExtensionSystem::Get(profile)->extension_service();
 354     if (!service) {
 355       *result = true;
 356       return true;
 357     }
 358     const Extension* extension =
 359         service->extensions()->GetExtensionOrAppByURL(to_url);
 360     if (!extension) {
 361       *result = true;
 362       return true;
 363     }
 364     const Extension* from_extension =
 365         service->extensions()->GetExtensionOrAppByURL(
 366             site_instance->GetSiteURL());
 367     if (from_extension && from_extension->id() == extension->id()) {
 368       *result = true;
 369       return true;
 370     }
 371
 372     if (!WebAccessibleResourcesInfo::IsResourceWebAccessible(
 373             extension, to_url.path())) {
 374       *result = false;
 375       return true;
 376     }
 377   }
 378   return false;
 379 }
 380
 381 // static
 382 void ChromeContentBrowserClientExtensionsPart::SetSigninProcess(
 383     content::SiteInstance* site_instance) {
 384   Profile* profile =
 385       Profile::FromBrowserContext(site_instance->GetBrowserContext());
 386   DCHECK(profile);
 387   BrowserThread::PostTask(
 388       BrowserThread::IO,
 389       FROM_HERE,
 390       base::Bind(&InfoMap::SetSigninProcess,
 391                  ExtensionSystem::Get(profile)->info_map(),
 392                  site_instance->GetProcess()->GetID()));
 393 }
 394
 395 void ChromeContentBrowserClientExtensionsPart::RenderProcessWillLaunch(
 396     content::RenderProcessHost* host) {
 397   int id = host->GetID();
 398   Profile* profile = Profile::FromBrowserContext(host->GetBrowserContext());
 399
 400   host->AddFilter(new ChromeExtensionMessageFilter(id, profile));
 401   host->AddFilter(new ExtensionMessageFilter(id, profile));
 402   extension_web_request_api_helpers::SendExtensionWebRequestStatusToHost(host);
 403 }
 404
 405 void ChromeContentBrowserClientExtensionsPart::SiteInstanceGotProcess(
 406     SiteInstance* site_instance) {
 407   Profile* profile = Profile::FromBrowserContext(
 408       site_instance->GetProcess()->GetBrowserContext());
 409   ExtensionService* service =
 410       ExtensionSystem::Get(profile)->extension_service();
 411   if (!service)
 412     return;
 413
 414   const Extension* extension = service->extensions()->GetExtensionOrAppByURL(
 415       site_instance->GetSiteURL());
 416   if (!extension)
 417     return;
 418
 419   ProcessMap::Get(profile)->Insert(extension->id(),
 420                                    site_instance->GetProcess()->GetID(),
 421                                    site_instance->GetId());
 422
 423   BrowserThread::PostTask(BrowserThread::IO,
 424                           FROM_HERE,
 425                           base::Bind(&InfoMap::RegisterExtensionProcess,
 426                                      ExtensionSystem::Get(profile)->info_map(),
 427                                      extension->id(),
 428                                      site_instance->GetProcess()->GetID(),
 429                                      site_instance->GetId()));
 430 }
 431
 432 void ChromeContentBrowserClientExtensionsPart::SiteInstanceDeleting(
 433     SiteInstance* site_instance) {
 434   Profile* profile =
 435       Profile::FromBrowserContext(site_instance->GetBrowserContext());
 436   ExtensionService* service =
 437       ExtensionSystem::Get(profile)->extension_service();
 438   if (!service)
 439     return;
 440
 441   const Extension* extension = service->extensions()->GetExtensionOrAppByURL(
 442       site_instance->GetSiteURL());
 443   if (!extension)
 444     return;
 445
 446   ProcessMap::Get(profile)->Remove(extension->id(),
 447                                    site_instance->GetProcess()->GetID(),
 448                                    site_instance->GetId());
 449
 450   BrowserThread::PostTask(BrowserThread::IO,
 451                           FROM_HERE,
 452                           base::Bind(&InfoMap::UnregisterExtensionProcess,
 453                                      ExtensionSystem::Get(profile)->info_map(),
 454                                      extension->id(),
 455                                      site_instance->GetProcess()->GetID(),
 456                                      site_instance->GetId()));
 457 }
 458
 459 void ChromeContentBrowserClientExtensionsPart::OverrideWebkitPrefs(
 460     RenderViewHost* rvh,
 461     const GURL& url,
 462     WebPreferences* web_prefs) {
 463   Profile* profile =
 464       Profile::FromBrowserContext(rvh->GetProcess()->GetBrowserContext());
 465
 466   ExtensionService* service =
 467       ExtensionSystem::Get(profile)->extension_service();
 468   if (!service)
 469     return;
 470
 471   // Note: it's not possible for kExtensionsScheme to change during the lifetime
 472   // of the process.
 473   //
 474   // Ensure that we are only granting extension preferences to URLs with
 475   // the correct scheme. Without this check, chrome-guest:// schemes used by
 476   // webview tags as well as hosts that happen to match the id of an
 477   // installed extension would get the wrong preferences.
 478   const GURL& site_url = rvh->GetSiteInstance()->GetSiteURL();
 479   if (!site_url.SchemeIs(kExtensionScheme))
 480     return;
 481
 482   WebContents* web_contents = WebContents::FromRenderViewHost(rvh);
 483   ViewType view_type = GetViewType(web_contents);
 484   const Extension* extension = service->extensions()->GetByID(site_url.host());
 485   extension_webkit_preferences::SetPreferences(extension, view_type, web_prefs);
 486 }
 487
 488 void ChromeContentBrowserClientExtensionsPart::BrowserURLHandlerCreated(
 489     BrowserURLHandler* handler) {
 490   handler->AddHandlerPair(&ExtensionWebUI::HandleChromeURLOverride,
 491                           BrowserURLHandler::null_handler());
 492   handler->AddHandlerPair(BrowserURLHandler::null_handler(),
 493                           &ExtensionWebUI::HandleChromeURLOverrideReverse);
 494 }
 495
 496 void ChromeContentBrowserClientExtensionsPart::
 497     GetAdditionalAllowedSchemesForFileSystem(
 498         std::vector<std::string>* additional_allowed_schemes) {
 499   additional_allowed_schemes->push_back(kExtensionScheme);
 500 }
 501
 502 void ChromeContentBrowserClientExtensionsPart::GetURLRequestAutoMountHandlers(
 503     std::vector<storage::URLRequestAutoMountHandler>* handlers) {
 504   handlers->push_back(
 505       base::Bind(MediaFileSystemBackend::AttemptAutoMountForURLRequest));
 506 }
 507
 508 void ChromeContentBrowserClientExtensionsPart::GetAdditionalFileSystemBackends(
 509     content::BrowserContext* browser_context,
 510     const base::FilePath& storage_partition_path,
 511     ScopedVector<storage::FileSystemBackend>* additional_backends) {
 512   base::SequencedWorkerPool* pool = content::BrowserThread::GetBlockingPool();
 513   additional_backends->push_back(new MediaFileSystemBackend(
 514       storage_partition_path,
 515       pool->GetSequencedTaskRunner(
 516                 pool->GetNamedSequenceToken(
 517                     MediaFileSystemBackend::kMediaTaskRunnerName)).get()));
 518
 519   additional_backends->push_back(new sync_file_system::SyncFileSystemBackend(
 520       Profile::FromBrowserContext(browser_context)));
 521 }
 522
 523 void ChromeContentBrowserClientExtensionsPart::
 524     AppendExtraRendererCommandLineSwitches(base::CommandLine* command_line,
 525                                            content::RenderProcessHost* process,
 526                                            Profile* profile) {
 527   if (!process)
 528     return;
 529   DCHECK(profile);
 530   if (ProcessMap::Get(profile)->Contains(process->GetID())) {
 531     command_line->AppendSwitch(switches::kExtensionProcess);
 532 #if defined(ENABLE_WEBRTC)
 533     command_line->AppendSwitch(::switches::kEnableWebRtcHWH264Encoding);
 534 #endif
 535   }
 536 }
 537
 538 }  // namespace extensions