src/content/shell/browser/shell_content_browser_client.cc

   1 // Copyright 2013 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 "content/shell/browser/shell_content_browser_client.h"
   6
   7 #include "base/base_switches.h"
   8 #include "base/command_line.h"
   9 #include "base/files/file.h"
  10 #include "base/files/file_util.h"
  11 #include "base/path_service.h"
  12 #include "base/strings/utf_string_conversions.h"
  13 #include "content/public/browser/render_process_host.h"
  14 #include "content/public/browser/resource_dispatcher_host.h"
  15 #include "content/public/browser/storage_partition.h"
  16 #include "content/public/common/content_switches.h"
  17 #include "content/public/common/url_constants.h"
  18 #include "content/public/common/web_preferences.h"
  19 #include "content/shell/browser/ipc_echo_message_filter.h"
  20 #include "content/shell/browser/shell.h"
  21 #include "content/shell/browser/shell_browser_context.h"
  22 #include "content/shell/browser/shell_browser_main_parts.h"
  23 #include "content/shell/browser/shell_devtools_delegate.h"
  24 #include "content/shell/browser/shell_message_filter.h"
  25 #include "content/shell/browser/shell_net_log.h"
  26 #include "content/shell/browser/shell_notification_manager.h"
  27 #include "content/shell/browser/shell_quota_permission_context.h"
  28 #include "content/shell/browser/shell_resource_dispatcher_host_delegate.h"
  29 #include "content/shell/browser/shell_web_contents_view_delegate_creator.h"
  30 #include "content/shell/browser/webkit_test_controller.h"
  31 #include "content/shell/common/shell_messages.h"
  32 #include "content/shell/common/shell_switches.h"
  33 #include "content/shell/common/webkit_test_helpers.h"
  34 #include "content/shell/geolocation/shell_access_token_store.h"
  35 #include "net/url_request/url_request_context_getter.h"
  36 #include "url/gurl.h"
  37
  38 #if defined(OS_ANDROID)
  39 #include "base/android/path_utils.h"
  40 #include "components/crash/browser/crash_dump_manager_android.h"
  41 #include "content/shell/android/shell_descriptors.h"
  42 #endif
  43
  44 #if defined(OS_POSIX) && !defined(OS_MACOSX)
  45 #include "base/debug/leak_annotations.h"
  46 #include "components/crash/app/breakpad_linux.h"
  47 #include "components/crash/browser/crash_handler_host_linux.h"
  48 #include "content/public/common/content_descriptors.h"
  49 #endif
  50
  51 #if defined(OS_WIN)
  52 #include "content/common/sandbox_win.h"
  53 #include "sandbox/win/src/sandbox.h"
  54 #endif
  55
  56 namespace content {
  57
  58 namespace {
  59
  60 ShellContentBrowserClient* g_browser_client;
  61 bool g_swap_processes_for_redirect = false;
  62
  63 #if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
  64 breakpad::CrashHandlerHostLinux* CreateCrashHandlerHost(
  65     const std::string& process_type) {
  66   base::FilePath dumps_path =
  67       CommandLine::ForCurrentProcess()->GetSwitchValuePath(
  68           switches::kCrashDumpsDir);
  69   {
  70     ANNOTATE_SCOPED_MEMORY_LEAK;
  71     breakpad::CrashHandlerHostLinux* crash_handler =
  72         new breakpad::CrashHandlerHostLinux(
  73             process_type, dumps_path, false);
  74     crash_handler->StartUploaderThread();
  75     return crash_handler;
  76   }
  77 }
  78
  79 int GetCrashSignalFD(const CommandLine& command_line) {
  80   if (!breakpad::IsCrashReporterEnabled())
  81     return -1;
  82
  83   std::string process_type =
  84       command_line.GetSwitchValueASCII(switches::kProcessType);
  85
  86   if (process_type == switches::kRendererProcess) {
  87     static breakpad::CrashHandlerHostLinux* crash_handler = NULL;
  88     if (!crash_handler)
  89       crash_handler = CreateCrashHandlerHost(process_type);
  90     return crash_handler->GetDeathSignalSocket();
  91   }
  92
  93   if (process_type == switches::kPluginProcess) {
  94     static breakpad::CrashHandlerHostLinux* crash_handler = NULL;
  95     if (!crash_handler)
  96       crash_handler = CreateCrashHandlerHost(process_type);
  97     return crash_handler->GetDeathSignalSocket();
  98   }
  99
 100   if (process_type == switches::kPpapiPluginProcess) {
 101     static breakpad::CrashHandlerHostLinux* crash_handler = NULL;
 102     if (!crash_handler)
 103       crash_handler = CreateCrashHandlerHost(process_type);
 104     return crash_handler->GetDeathSignalSocket();
 105   }
 106
 107   if (process_type == switches::kGpuProcess) {
 108     static breakpad::CrashHandlerHostLinux* crash_handler = NULL;
 109     if (!crash_handler)
 110       crash_handler = CreateCrashHandlerHost(process_type);
 111     return crash_handler->GetDeathSignalSocket();
 112   }
 113
 114   return -1;
 115 }
 116 #endif  // defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
 117
 118 void RequestDesktopNotificationPermissionOnIO(
 119     const GURL& source_origin,
 120     RenderFrameHost* render_frame_host,
 121     const base::Callback<void(blink::WebNotificationPermission)>& callback) {
 122   ShellNotificationManager* manager =
 123       ShellContentBrowserClient::Get()->GetShellNotificationManager();
 124   if (manager)
 125     manager->RequestPermission(source_origin, callback);
 126   else
 127     callback.Run(blink::WebNotificationPermissionAllowed);
 128 }
 129
 130 }  // namespace
 131
 132 ShellContentBrowserClient* ShellContentBrowserClient::Get() {
 133   return g_browser_client;
 134 }
 135
 136 void ShellContentBrowserClient::SetSwapProcessesForRedirect(bool swap) {
 137   g_swap_processes_for_redirect = swap;
 138 }
 139
 140 ShellContentBrowserClient::ShellContentBrowserClient()
 141     : shell_browser_main_parts_(NULL) {
 142   DCHECK(!g_browser_client);
 143   g_browser_client = this;
 144   if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kDumpRenderTree))
 145     return;
 146   webkit_source_dir_ = GetWebKitRootDirFilePath();
 147 }
 148
 149 ShellContentBrowserClient::~ShellContentBrowserClient() {
 150   g_browser_client = NULL;
 151 }
 152
 153 ShellNotificationManager*
 154 ShellContentBrowserClient::GetShellNotificationManager() {
 155   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 156   if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kDumpRenderTree))
 157     return NULL;
 158
 159   if (!shell_notification_manager_)
 160     shell_notification_manager_.reset(new ShellNotificationManager());
 161
 162   return shell_notification_manager_.get();
 163 }
 164
 165 BrowserMainParts* ShellContentBrowserClient::CreateBrowserMainParts(
 166     const MainFunctionParams& parameters) {
 167   shell_browser_main_parts_ = new ShellBrowserMainParts(parameters);
 168   return shell_browser_main_parts_;
 169 }
 170
 171 void ShellContentBrowserClient::RenderProcessWillLaunch(
 172     RenderProcessHost* host) {
 173   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kExposeIpcEcho))
 174     host->AddFilter(new IPCEchoMessageFilter());
 175   if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kDumpRenderTree))
 176     return;
 177   host->AddFilter(new ShellMessageFilter(
 178       host->GetID(),
 179       BrowserContext::GetDefaultStoragePartition(browser_context())
 180           ->GetDatabaseTracker(),
 181       BrowserContext::GetDefaultStoragePartition(browser_context())
 182           ->GetQuotaManager(),
 183       BrowserContext::GetDefaultStoragePartition(browser_context())
 184           ->GetURLRequestContext()));
 185   host->Send(new ShellViewMsg_SetWebKitSourceDir(webkit_source_dir_));
 186 }
 187
 188 net::URLRequestContextGetter* ShellContentBrowserClient::CreateRequestContext(
 189     BrowserContext* content_browser_context,
 190     ProtocolHandlerMap* protocol_handlers,
 191     URLRequestInterceptorScopedVector request_interceptors) {
 192   ShellBrowserContext* shell_browser_context =
 193       ShellBrowserContextForBrowserContext(content_browser_context);
 194   return shell_browser_context->CreateRequestContext(
 195       protocol_handlers, request_interceptors.Pass());
 196 }
 197
 198 net::URLRequestContextGetter*
 199 ShellContentBrowserClient::CreateRequestContextForStoragePartition(
 200     BrowserContext* content_browser_context,
 201     const base::FilePath& partition_path,
 202     bool in_memory,
 203     ProtocolHandlerMap* protocol_handlers,
 204     URLRequestInterceptorScopedVector request_interceptors) {
 205   ShellBrowserContext* shell_browser_context =
 206       ShellBrowserContextForBrowserContext(content_browser_context);
 207   return shell_browser_context->CreateRequestContextForStoragePartition(
 208       partition_path,
 209       in_memory,
 210       protocol_handlers,
 211       request_interceptors.Pass());
 212 }
 213
 214 bool ShellContentBrowserClient::IsHandledURL(const GURL& url) {
 215   if (!url.is_valid())
 216     return false;
 217   DCHECK_EQ(url.scheme(), base::StringToLowerASCII(url.scheme()));
 218   // Keep in sync with ProtocolHandlers added by
 219   // ShellURLRequestContextGetter::GetURLRequestContext().
 220   static const char* const kProtocolList[] = {
 221       url::kBlobScheme,
 222       url::kFileSystemScheme,
 223       kChromeUIScheme,
 224       kChromeDevToolsScheme,
 225       url::kDataScheme,
 226       url::kFileScheme,
 227   };
 228   for (size_t i = 0; i < arraysize(kProtocolList); ++i) {
 229     if (url.scheme() == kProtocolList[i])
 230       return true;
 231   }
 232   return false;
 233 }
 234
 235 void ShellContentBrowserClient::AppendExtraCommandLineSwitches(
 236     CommandLine* command_line, int child_process_id) {
 237   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kDumpRenderTree))
 238     command_line->AppendSwitch(switches::kDumpRenderTree);
 239   if (CommandLine::ForCurrentProcess()->HasSwitch(
 240       switches::kEnableFontAntialiasing))
 241     command_line->AppendSwitch(switches::kEnableFontAntialiasing);
 242   if (CommandLine::ForCurrentProcess()->HasSwitch(
 243       switches::kExposeInternalsForTesting))
 244     command_line->AppendSwitch(switches::kExposeInternalsForTesting);
 245   if (CommandLine::ForCurrentProcess()->HasSwitch(
 246       switches::kExposeIpcEcho))
 247     command_line->AppendSwitch(switches::kExposeIpcEcho);
 248   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kStableReleaseMode))
 249     command_line->AppendSwitch(switches::kStableReleaseMode);
 250   if (CommandLine::ForCurrentProcess()->HasSwitch(
 251           switches::kEnableCrashReporter)) {
 252     command_line->AppendSwitch(switches::kEnableCrashReporter);
 253   }
 254   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kCrashDumpsDir)) {
 255     command_line->AppendSwitchPath(
 256         switches::kCrashDumpsDir,
 257         CommandLine::ForCurrentProcess()->GetSwitchValuePath(
 258             switches::kCrashDumpsDir));
 259   }
 260   if (CommandLine::ForCurrentProcess()->HasSwitch(
 261           switches::kEnableLeakDetection)) {
 262     command_line->AppendSwitchASCII(
 263         switches::kEnableLeakDetection,
 264         CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
 265             switches::kEnableLeakDetection));
 266   }
 267   if (CommandLine::ForCurrentProcess()->HasSwitch(
 268         switches::kRegisterFontFiles)) {
 269     command_line->AppendSwitchASCII(
 270         switches::kRegisterFontFiles,
 271         CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
 272             switches::kRegisterFontFiles));
 273   }
 274 }
 275
 276 void ShellContentBrowserClient::OverrideWebkitPrefs(
 277     RenderViewHost* render_view_host,
 278     const GURL& url,
 279     WebPreferences* prefs) {
 280   if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kDumpRenderTree))
 281     return;
 282   WebKitTestController::Get()->OverrideWebkitPrefs(prefs);
 283 }
 284
 285 void ShellContentBrowserClient::ResourceDispatcherHostCreated() {
 286   resource_dispatcher_host_delegate_.reset(
 287       new ShellResourceDispatcherHostDelegate());
 288   ResourceDispatcherHost::Get()->SetDelegate(
 289       resource_dispatcher_host_delegate_.get());
 290 }
 291
 292 std::string ShellContentBrowserClient::GetDefaultDownloadName() {
 293   return "download";
 294 }
 295
 296 WebContentsViewDelegate* ShellContentBrowserClient::GetWebContentsViewDelegate(
 297     WebContents* web_contents) {
 298 #if !defined(USE_AURA)
 299   return CreateShellWebContentsViewDelegate(web_contents);
 300 #else
 301   return NULL;
 302 #endif
 303 }
 304
 305 QuotaPermissionContext*
 306 ShellContentBrowserClient::CreateQuotaPermissionContext() {
 307   return new ShellQuotaPermissionContext();
 308 }
 309
 310 void ShellContentBrowserClient::RequestDesktopNotificationPermission(
 311     const GURL& source_origin,
 312     RenderFrameHost* render_frame_host,
 313     const base::Callback<void(blink::WebNotificationPermission)>& callback) {
 314   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 315   BrowserThread::PostTask(BrowserThread::IO,
 316                           FROM_HERE,
 317                           base::Bind(&RequestDesktopNotificationPermissionOnIO,
 318                               source_origin,
 319                               render_frame_host,
 320                               callback));
 321 }
 322
 323 blink::WebNotificationPermission
 324 ShellContentBrowserClient::CheckDesktopNotificationPermission(
 325     const GURL& source_url,
 326     ResourceContext* context,
 327     int render_process_id) {
 328   ShellNotificationManager* manager = GetShellNotificationManager();
 329   if (manager)
 330     return manager->CheckPermission(source_url);
 331
 332   return blink::WebNotificationPermissionAllowed;
 333 }
 334
 335 SpeechRecognitionManagerDelegate*
 336     ShellContentBrowserClient::GetSpeechRecognitionManagerDelegate() {
 337   return new ShellSpeechRecognitionManagerDelegate();
 338 }
 339
 340 net::NetLog* ShellContentBrowserClient::GetNetLog() {
 341   return shell_browser_main_parts_->net_log();
 342 }
 343
 344 bool ShellContentBrowserClient::ShouldSwapProcessesForRedirect(
 345     ResourceContext* resource_context,
 346     const GURL& current_url,
 347     const GURL& new_url) {
 348   return g_swap_processes_for_redirect;
 349 }
 350
 351 DevToolsManagerDelegate*
 352 ShellContentBrowserClient::GetDevToolsManagerDelegate() {
 353   return new ShellDevToolsManagerDelegate(browser_context());
 354 }
 355
 356 #if defined(OS_POSIX) && !defined(OS_MACOSX)
 357 void ShellContentBrowserClient::GetAdditionalMappedFilesForChildProcess(
 358     const CommandLine& command_line,
 359     int child_process_id,
 360     std::vector<FileDescriptorInfo>* mappings) {
 361 #if defined(OS_ANDROID)
 362   int flags = base::File::FLAG_OPEN | base::File::FLAG_READ;
 363   base::FilePath pak_file;
 364   bool r = PathService::Get(base::DIR_ANDROID_APP_DATA, &pak_file);
 365   CHECK(r);
 366   pak_file = pak_file.Append(FILE_PATH_LITERAL("paks"));
 367   pak_file = pak_file.Append(FILE_PATH_LITERAL("content_shell.pak"));
 368
 369   base::File f(pak_file, flags);
 370   if (!f.IsValid()) {
 371     NOTREACHED() << "Failed to open file when creating renderer process: "
 372                  << "content_shell.pak";
 373   }
 374   mappings->push_back(
 375       FileDescriptorInfo(kShellPakDescriptor, base::FileDescriptor(f.Pass())));
 376
 377   if (breakpad::IsCrashReporterEnabled()) {
 378     f = breakpad::CrashDumpManager::GetInstance()->CreateMinidumpFile(
 379         child_process_id);
 380     if (!f.IsValid()) {
 381       LOG(ERROR) << "Failed to create file for minidump, crash reporting will "
 382                  << "be disabled for this process.";
 383     } else {
 384       mappings->push_back(
 385           FileDescriptorInfo(kAndroidMinidumpDescriptor,
 386                              base::FileDescriptor(f.Pass())));
 387     }
 388   }
 389 #else  // !defined(OS_ANDROID)
 390   int crash_signal_fd = GetCrashSignalFD(command_line);
 391   if (crash_signal_fd >= 0) {
 392     mappings->push_back(FileDescriptorInfo(
 393         kCrashDumpSignal, base::FileDescriptor(crash_signal_fd, false)));
 394   }
 395 #endif  // defined(OS_ANDROID)
 396 }
 397 #endif  // defined(OS_POSIX) && !defined(OS_MACOSX)
 398
 399 #if defined(OS_WIN)
 400 void ShellContentBrowserClient::PreSpawnRenderer(sandbox::TargetPolicy* policy,
 401                                                  bool* success) {
 402   // Add sideloaded font files for testing. See also DIR_WINDOWS_FONTS
 403   // addition in |StartSandboxedProcess|.
 404   std::vector<std::string> font_files = GetSideloadFontFiles();
 405   for (std::vector<std::string>::const_iterator i(font_files.begin());
 406       i != font_files.end();
 407       ++i) {
 408     policy->AddRule(sandbox::TargetPolicy::SUBSYS_FILES,
 409         sandbox::TargetPolicy::FILES_ALLOW_READONLY,
 410         base::UTF8ToWide(*i).c_str());
 411   }
 412 }
 413 #endif  // OS_WIN
 414
 415 ShellBrowserContext* ShellContentBrowserClient::browser_context() {
 416   return shell_browser_main_parts_->browser_context();
 417 }
 418
 419 ShellBrowserContext*
 420     ShellContentBrowserClient::off_the_record_browser_context() {
 421   return shell_browser_main_parts_->off_the_record_browser_context();
 422 }
 423
 424 AccessTokenStore* ShellContentBrowserClient::CreateAccessTokenStore() {
 425   return new ShellAccessTokenStore(browser_context());
 426 }
 427
 428 ShellBrowserContext*
 429 ShellContentBrowserClient::ShellBrowserContextForBrowserContext(
 430     BrowserContext* content_browser_context) {
 431   if (content_browser_context == browser_context())
 432     return browser_context();
 433   DCHECK_EQ(content_browser_context, off_the_record_browser_context());
 434   return off_the_record_browser_context();
 435 }
 436
 437 }  // namespace content