extensions/shell/browser/shell_content_browser_client.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 "extensions/shell/browser/shell_content_browser_client.h"
   6
   7 #include "base/command_line.h"
   8 #include "components/guest_view/browser/guest_view_message_filter.h"
   9 #include "content/public/browser/browser_thread.h"
  10 #include "content/public/browser/render_process_host.h"
  11 #include "content/public/browser/site_instance.h"
  12 #include "content/public/common/content_descriptors.h"
  13 #include "content/public/common/content_switches.h"
  14 #include "content/public/common/url_constants.h"
  15 #include "content/shell/browser/shell_browser_context.h"
  16 #include "content/shell/browser/shell_devtools_manager_delegate.h"
  17 #include "extensions/browser/extension_message_filter.h"
  18 #include "extensions/browser/extension_protocols.h"
  19 #include "extensions/browser/extension_registry.h"
  20 #include "extensions/browser/guest_view/extensions_guest_view_message_filter.h"
  21 #include "extensions/browser/info_map.h"
  22 #include "extensions/browser/io_thread_extension_message_filter.h"
  23 #include "extensions/browser/process_map.h"
  24 #include "extensions/common/constants.h"
  25 #include "extensions/common/extension.h"
  26 #include "extensions/common/switches.h"
  27 #include "extensions/shell/browser/shell_browser_context.h"
  28 #include "extensions/shell/browser/shell_browser_main_parts.h"
  29 #include "extensions/shell/browser/shell_extension_system.h"
  30 #include "extensions/shell/browser/shell_speech_recognition_manager_delegate.h"
  31 #include "gin/v8_initializer.h"
  32 #include "url/gurl.h"
  33
  34 #if !defined(DISABLE_NACL)
  35 #include "components/nacl/browser/nacl_browser.h"
  36 #include "components/nacl/browser/nacl_host_message_filter.h"
  37 #include "components/nacl/browser/nacl_process_host.h"
  38 #include "components/nacl/common/nacl_process_type.h"
  39 #include "components/nacl/common/nacl_switches.h"
  40 #include "content/public/browser/browser_child_process_host.h"
  41 #include "content/public/browser/child_process_data.h"
  42 #endif
  43
  44 using base::CommandLine;
  45 using content::BrowserContext;
  46 using content::BrowserThread;
  47
  48 namespace extensions {
  49 namespace {
  50
  51 ShellContentBrowserClient* g_instance = nullptr;
  52
  53 }  // namespace
  54
  55 ShellContentBrowserClient::ShellContentBrowserClient(
  56     ShellBrowserMainDelegate* browser_main_delegate)
  57     :
  58 #if defined(OS_POSIX) && !defined(OS_MACOSX)
  59       v8_natives_fd_(-1),
  60       v8_snapshot_fd_(-1),
  61 #endif  // OS_POSIX && !OS_MACOSX
  62       browser_main_parts_(nullptr),
  63       browser_main_delegate_(browser_main_delegate) {
  64   DCHECK(!g_instance);
  65   g_instance = this;
  66 }
  67
  68 ShellContentBrowserClient::~ShellContentBrowserClient() {
  69   g_instance = nullptr;
  70 }
  71
  72 // static
  73 ShellContentBrowserClient* ShellContentBrowserClient::Get() {
  74   return g_instance;
  75 }
  76
  77 content::BrowserContext* ShellContentBrowserClient::GetBrowserContext() {
  78   return browser_main_parts_->browser_context();
  79 }
  80
  81 content::BrowserMainParts* ShellContentBrowserClient::CreateBrowserMainParts(
  82     const content::MainFunctionParams& parameters) {
  83   browser_main_parts_ =
  84       CreateShellBrowserMainParts(parameters, browser_main_delegate_);
  85   return browser_main_parts_;
  86 }
  87
  88 void ShellContentBrowserClient::RenderProcessWillLaunch(
  89     content::RenderProcessHost* host) {
  90   int render_process_id = host->GetID();
  91   BrowserContext* browser_context = browser_main_parts_->browser_context();
  92   host->AddFilter(
  93       new ExtensionMessageFilter(render_process_id, browser_context));
  94   host->AddFilter(
  95       new IOThreadExtensionMessageFilter(render_process_id, browser_context));
  96   host->AddFilter(
  97       new guest_view::GuestViewMessageFilter(
  98           render_process_id, browser_context));
  99   host->AddFilter(
 100       new ExtensionsGuestViewMessageFilter(
 101           render_process_id, browser_context));
 102   // PluginInfoMessageFilter is not required because app_shell does not have
 103   // the concept of disabled plugins.
 104 #if !defined(DISABLE_NACL)
 105   host->AddFilter(new nacl::NaClHostMessageFilter(
 106       render_process_id,
 107       browser_context->IsOffTheRecord(),
 108       browser_context->GetPath(),
 109       browser_context->GetRequestContextForRenderProcess(render_process_id)));
 110 #endif
 111 }
 112
 113 bool ShellContentBrowserClient::ShouldUseProcessPerSite(
 114     content::BrowserContext* browser_context,
 115     const GURL& effective_url) {
 116   // This ensures that all render views created for a single app will use the
 117   // same render process (see content::SiteInstance::GetProcess). Otherwise the
 118   // default behavior of ContentBrowserClient will lead to separate render
 119   // processes for the background page and each app window view.
 120   return true;
 121 }
 122
 123 net::URLRequestContextGetter* ShellContentBrowserClient::CreateRequestContext(
 124     content::BrowserContext* content_browser_context,
 125     content::ProtocolHandlerMap* protocol_handlers,
 126     content::URLRequestInterceptorScopedVector request_interceptors) {
 127   // Handle only chrome-extension:// requests. app_shell does not support
 128   // chrome-extension-resource:// requests (it does not store shared extension
 129   // data in its installation directory).
 130   InfoMap* extension_info_map =
 131       browser_main_parts_->extension_system()->info_map();
 132   (*protocol_handlers)[kExtensionScheme] =
 133       linked_ptr<net::URLRequestJobFactory::ProtocolHandler>(
 134           CreateExtensionProtocolHandler(false /* is_incognito */,
 135                                          extension_info_map));
 136   return browser_main_parts_->browser_context()->CreateRequestContext(
 137       protocol_handlers, request_interceptors.Pass(), extension_info_map);
 138 }
 139
 140 bool ShellContentBrowserClient::IsHandledURL(const GURL& url) {
 141   if (!url.is_valid())
 142     return false;
 143   // Keep in sync with ProtocolHandlers added in CreateRequestContext() and in
 144   // content::ShellURLRequestContextGetter::GetURLRequestContext().
 145   static const char* const kProtocolList[] = {
 146       url::kBlobScheme,
 147       content::kChromeDevToolsScheme,
 148       content::kChromeUIScheme,
 149       url::kDataScheme,
 150       url::kFileScheme,
 151       url::kFileSystemScheme,
 152       kExtensionScheme,
 153       kExtensionResourceScheme,
 154   };
 155   for (size_t i = 0; i < arraysize(kProtocolList); ++i) {
 156     if (url.scheme() == kProtocolList[i])
 157       return true;
 158   }
 159   return false;
 160 }
 161
 162 void ShellContentBrowserClient::SiteInstanceGotProcess(
 163     content::SiteInstance* site_instance) {
 164   // If this isn't an extension renderer there's nothing to do.
 165   const Extension* extension = GetExtension(site_instance);
 166   if (!extension)
 167     return;
 168
 169   ProcessMap::Get(browser_main_parts_->browser_context())
 170       ->Insert(extension->id(),
 171                site_instance->GetProcess()->GetID(),
 172                site_instance->GetId());
 173
 174   BrowserThread::PostTask(
 175       BrowserThread::IO,
 176       FROM_HERE,
 177       base::Bind(&InfoMap::RegisterExtensionProcess,
 178                  browser_main_parts_->extension_system()->info_map(),
 179                  extension->id(),
 180                  site_instance->GetProcess()->GetID(),
 181                  site_instance->GetId()));
 182 }
 183
 184 void ShellContentBrowserClient::SiteInstanceDeleting(
 185     content::SiteInstance* site_instance) {
 186   // If this isn't an extension renderer there's nothing to do.
 187   const Extension* extension = GetExtension(site_instance);
 188   if (!extension)
 189     return;
 190
 191   ProcessMap::Get(browser_main_parts_->browser_context())
 192       ->Remove(extension->id(),
 193                site_instance->GetProcess()->GetID(),
 194                site_instance->GetId());
 195
 196   BrowserThread::PostTask(
 197       BrowserThread::IO,
 198       FROM_HERE,
 199       base::Bind(&InfoMap::UnregisterExtensionProcess,
 200                  browser_main_parts_->extension_system()->info_map(),
 201                  extension->id(),
 202                  site_instance->GetProcess()->GetID(),
 203                  site_instance->GetId()));
 204 }
 205
 206 void ShellContentBrowserClient::AppendExtraCommandLineSwitches(
 207     base::CommandLine* command_line,
 208     int child_process_id) {
 209   std::string process_type =
 210       command_line->GetSwitchValueASCII(::switches::kProcessType);
 211
 212 #if defined(OS_POSIX) && !defined(OS_MACOSX)
 213 #if defined(V8_USE_EXTERNAL_STARTUP_DATA)
 214   if (process_type != ::switches::kZygoteProcess) {
 215     command_line->AppendSwitch(::switches::kV8NativesPassedByFD);
 216     command_line->AppendSwitch(::switches::kV8SnapshotPassedByFD);
 217   }
 218 #endif  // V8_USE_EXTERNAL_STARTUP_DATA
 219 #endif  // OS_POSIX && !OS_MACOSX
 220
 221   if (process_type == ::switches::kRendererProcess)
 222     AppendRendererSwitches(command_line);
 223 }
 224
 225 content::SpeechRecognitionManagerDelegate*
 226 ShellContentBrowserClient::CreateSpeechRecognitionManagerDelegate() {
 227   return new speech::ShellSpeechRecognitionManagerDelegate();
 228 }
 229
 230 content::BrowserPpapiHost*
 231 ShellContentBrowserClient::GetExternalBrowserPpapiHost(int plugin_process_id) {
 232 #if !defined(DISABLE_NACL)
 233   content::BrowserChildProcessHostIterator iter(PROCESS_TYPE_NACL_LOADER);
 234   while (!iter.Done()) {
 235     nacl::NaClProcessHost* host = static_cast<nacl::NaClProcessHost*>(
 236         iter.GetDelegate());
 237     if (host->process() &&
 238         host->process()->GetData().id == plugin_process_id) {
 239       // Found the plugin.
 240       return host->browser_ppapi_host();
 241     }
 242     ++iter;
 243   }
 244 #endif
 245   return nullptr;
 246 }
 247
 248 void ShellContentBrowserClient::GetAdditionalAllowedSchemesForFileSystem(
 249     std::vector<std::string>* additional_allowed_schemes) {
 250   ContentBrowserClient::GetAdditionalAllowedSchemesForFileSystem(
 251       additional_allowed_schemes);
 252   additional_allowed_schemes->push_back(kExtensionScheme);
 253 }
 254
 255 #if defined(OS_POSIX) && !defined(OS_MACOSX)
 256 void ShellContentBrowserClient::GetAdditionalMappedFilesForChildProcess(
 257     const base::CommandLine& command_line,
 258     int child_process_id,
 259     content::FileDescriptorInfo* mappings) {
 260 #if defined(V8_USE_EXTERNAL_STARTUP_DATA)
 261   if (v8_natives_fd_.get() == -1 || v8_snapshot_fd_.get() == -1) {
 262     int v8_natives_fd = -1;
 263     int v8_snapshot_fd = -1;
 264     if (gin::V8Initializer::OpenV8FilesForChildProcesses(&v8_natives_fd,
 265                                                          &v8_snapshot_fd)) {
 266       v8_natives_fd_.reset(v8_natives_fd);
 267       v8_snapshot_fd_.reset(v8_snapshot_fd);
 268     }
 269   }
 270   DCHECK(v8_natives_fd_.get() != -1 && v8_snapshot_fd_.get() != -1);
 271   mappings->Share(kV8NativesDataDescriptor, v8_natives_fd_.get());
 272   mappings->Share(kV8SnapshotDataDescriptor, v8_snapshot_fd_.get());
 273 #endif  // V8_USE_EXTERNAL_STARTUP_DATA
 274 }
 275 #endif  // OS_POSIX && !OS_MACOSX
 276
 277 content::DevToolsManagerDelegate*
 278 ShellContentBrowserClient::GetDevToolsManagerDelegate() {
 279   return new content::ShellDevToolsManagerDelegate(GetBrowserContext());
 280 }
 281
 282 ShellBrowserMainParts* ShellContentBrowserClient::CreateShellBrowserMainParts(
 283     const content::MainFunctionParams& parameters,
 284     ShellBrowserMainDelegate* browser_main_delegate) {
 285   return new ShellBrowserMainParts(parameters, browser_main_delegate);
 286 }
 287
 288 void ShellContentBrowserClient::AppendRendererSwitches(
 289     base::CommandLine* command_line) {
 290   // TODO(jamescook): Should we check here if the process is in the extension
 291   // service process map, or can we assume all renderers are extension
 292   // renderers?
 293   command_line->AppendSwitch(switches::kExtensionProcess);
 294
 295 #if !defined(DISABLE_NACL)
 296   // NOTE: app_shell does not support non-SFI mode, so it does not pass through
 297   // SFI switches either here or for the zygote process.
 298   static const char* const kSwitchNames[] = {
 299     ::switches::kEnableNaClDebug,
 300   };
 301   command_line->CopySwitchesFrom(*base::CommandLine::ForCurrentProcess(),
 302                                  kSwitchNames, arraysize(kSwitchNames));
 303 #endif  // !defined(DISABLE_NACL)
 304 }
 305
 306 const Extension* ShellContentBrowserClient::GetExtension(
 307     content::SiteInstance* site_instance) {
 308   ExtensionRegistry* registry =
 309       ExtensionRegistry::Get(site_instance->GetBrowserContext());
 310   return registry->enabled_extensions().GetExtensionOrAppByURL(
 311       site_instance->GetSiteURL());
 312 }
 313
 314 }  // namespace extensions