src/content/renderer/render_thread_impl.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 "content/renderer/render_thread_impl.h"
   6
   7 #include <algorithm>
   8 #include <limits>
   9 #include <map>
  10 #include <vector>
  11
  12 #include "base/allocator/allocator_extension.h"
  13 #include "base/command_line.h"
  14 #include "base/debug/trace_event.h"
  15 #include "base/lazy_instance.h"
  16 #include "base/logging.h"
  17 #include "base/memory/discardable_memory.h"
  18 #include "base/memory/shared_memory.h"
  19 #include "base/metrics/field_trial.h"
  20 #include "base/metrics/histogram.h"
  21 #include "base/metrics/stats_table.h"
  22 #include "base/path_service.h"
  23 #include "base/strings/string16.h"
  24 #include "base/strings/string_number_conversions.h"
  25 #include "base/strings/string_tokenizer.h"
  26 #include "base/strings/utf_string_conversions.h"
  27 #include "base/threading/thread_local.h"
  28 #include "base/threading/thread_restrictions.h"
  29 #include "base/values.h"
  30 #include "cc/base/switches.h"
  31 #include "cc/resources/raster_worker_pool.h"
  32 #include "content/child/appcache/appcache_dispatcher.h"
  33 #include "content/child/appcache/appcache_frontend_impl.h"
  34 #include "content/child/child_histogram_message_filter.h"
  35 #include "content/child/db_message_filter.h"
  36 #include "content/child/indexed_db/indexed_db_dispatcher.h"
  37 #include "content/child/indexed_db/indexed_db_message_filter.h"
  38 #include "content/child/npapi/npobject_util.h"
  39 #include "content/child/plugin_messages.h"
  40 #include "content/child/resource_dispatcher.h"
  41 #include "content/child/runtime_features.h"
  42 #include "content/child/thread_safe_sender.h"
  43 #include "content/child/web_database_observer_impl.h"
  44 #include "content/child/worker_task_runner.h"
  45 #include "content/common/child_process_messages.h"
  46 #include "content/common/content_constants_internal.h"
  47 #include "content/common/database_messages.h"
  48 #include "content/common/dom_storage/dom_storage_messages.h"
  49 #include "content/common/gpu/client/context_provider_command_buffer.h"
  50 #include "content/common/gpu/client/gpu_channel_host.h"
  51 #include "content/common/gpu/client/gpu_memory_buffer_impl.h"
  52 #include "content/common/gpu/gpu_messages.h"
  53 #include "content/common/gpu/gpu_process_launch_causes.h"
  54 #include "content/common/resource_messages.h"
  55 #include "content/common/view_messages.h"
  56 #include "content/common/worker_messages.h"
  57 #include "content/public/common/content_constants.h"
  58 #include "content/public/common/content_paths.h"
  59 #include "content/public/common/content_switches.h"
  60 #include "content/public/common/renderer_preferences.h"
  61 #include "content/public/common/url_constants.h"
  62 #include "content/public/renderer/content_renderer_client.h"
  63 #include "content/public/renderer/render_process_observer.h"
  64 #include "content/public/renderer/render_view_visitor.h"
  65 #include "content/renderer/devtools/devtools_agent_filter.h"
  66 #include "content/renderer/dom_storage/dom_storage_dispatcher.h"
  67 #include "content/renderer/dom_storage/webstoragearea_impl.h"
  68 #include "content/renderer/dom_storage/webstoragenamespace_impl.h"
  69 #include "content/renderer/gamepad_shared_memory_reader.h"
  70 #include "content/renderer/gpu/compositor_output_surface.h"
  71 #include "content/renderer/gpu/gpu_benchmarking_extension.h"
  72 #include "content/renderer/input/input_event_filter.h"
  73 #include "content/renderer/input/input_handler_manager.h"
  74 #include "content/renderer/media/audio_input_message_filter.h"
  75 #include "content/renderer/media/audio_message_filter.h"
  76 #include "content/renderer/media/audio_renderer_mixer_manager.h"
  77 #include "content/renderer/media/media_stream_center.h"
  78 #include "content/renderer/media/media_stream_dependency_factory.h"
  79 #include "content/renderer/media/midi_message_filter.h"
  80 #include "content/renderer/media/peer_connection_tracker.h"
  81 #include "content/renderer/media/renderer_gpu_video_accelerator_factories.h"
  82 #include "content/renderer/media/video_capture_impl_manager.h"
  83 #include "content/renderer/media/video_capture_message_filter.h"
  84 #include "content/renderer/media/webrtc_identity_service.h"
  85 #include "content/renderer/p2p/socket_dispatcher.h"
  86 #include "content/renderer/render_process_impl.h"
  87 #include "content/renderer/render_view_impl.h"
  88 #include "content/renderer/renderer_webkitplatformsupport_impl.h"
  89 #include "content/renderer/service_worker/embedded_worker_context_message_filter.h"
  90 #include "content/renderer/service_worker/embedded_worker_dispatcher.h"
  91 #include "content/renderer/shared_worker/embedded_shared_worker_stub.h"
  92 #include "grit/content_resources.h"
  93 #include "ipc/ipc_channel_handle.h"
  94 #include "ipc/ipc_forwarding_message_filter.h"
  95 #include "ipc/ipc_platform_file.h"
  96 #include "media/base/audio_hardware_config.h"
  97 #include "media/base/media.h"
  98 #include "media/filters/gpu_video_accelerator_factories.h"
  99 #include "net/base/net_errors.h"
 100 #include "net/base/net_util.h"
 101 #include "skia/ext/event_tracer_impl.h"
 102 #include "third_party/WebKit/public/platform/WebString.h"
 103 #include "third_party/WebKit/public/web/WebColorName.h"
 104 #include "third_party/WebKit/public/web/WebDatabase.h"
 105 #include "third_party/WebKit/public/web/WebDocument.h"
 106 #include "third_party/WebKit/public/web/WebFrame.h"
 107 #include "third_party/WebKit/public/web/WebImageCache.h"
 108 #include "third_party/WebKit/public/web/WebKit.h"
 109 #include "third_party/WebKit/public/web/WebNetworkStateNotifier.h"
 110 #include "third_party/WebKit/public/web/WebPopupMenu.h"
 111 #include "third_party/WebKit/public/web/WebRuntimeFeatures.h"
 112 #include "third_party/WebKit/public/web/WebScriptController.h"
 113 #include "third_party/WebKit/public/web/WebSecurityPolicy.h"
 114 #include "third_party/WebKit/public/web/WebView.h"
 115 #include "third_party/skia/include/core/SkGraphics.h"
 116 #include "ui/base/layout.h"
 117 #include "ui/base/ui_base_switches.h"
 118 #include "v8/include/v8.h"
 119 #include "webkit/renderer/compositor_bindings/web_external_bitmap_impl.h"
 120 #include "webkit/renderer/compositor_bindings/web_layer_impl.h"
 121
 122 #if defined(OS_ANDROID)
 123 #include <cpu-features.h>
 124 #include "content/renderer/android/synchronous_compositor_factory.h"
 125 #include "content/renderer/media/android/renderer_demuxer_android.h"
 126 #endif
 127
 128 #if defined(OS_MACOSX)
 129 #include "content/renderer/webscrollbarbehavior_impl_mac.h"
 130 #endif
 131
 132 #if defined(OS_POSIX)
 133 #include "ipc/ipc_channel_posix.h"
 134 #endif
 135
 136 #if defined(OS_WIN)
 137 #include <windows.h>
 138 #include <objbase.h>
 139 #else
 140 // TODO(port)
 141 #include "base/memory/scoped_handle.h"
 142 #include "content/child/npapi/np_channel_base.h"
 143 #endif
 144
 145 #if defined(ENABLE_PLUGINS)
 146 #include "content/renderer/npapi/plugin_channel_host.h"
 147 #endif
 148
 149 #if defined(USE_MOJO)
 150 #include "content/renderer/mojo/mojo_render_process_observer.h"
 151 #endif
 152
 153 using base::ThreadRestrictions;
 154 using blink::WebDocument;
 155 using blink::WebFrame;
 156 using blink::WebNetworkStateNotifier;
 157 using blink::WebRuntimeFeatures;
 158 using blink::WebScriptController;
 159 using blink::WebSecurityPolicy;
 160 using blink::WebString;
 161 using blink::WebView;
 162
 163 namespace content {
 164
 165 namespace {
 166
 167 const int64 kInitialIdleHandlerDelayMs = 1000;
 168 const int64 kShortIdleHandlerDelayMs = 1000;
 169 const int64 kLongIdleHandlerDelayMs = 30*1000;
 170 const int kIdleCPUUsageThresholdInPercents = 3;
 171 const int kMinRasterThreads = 1;
 172 const int kMaxRasterThreads = 64;
 173
 174 // Keep the global RenderThreadImpl in a TLS slot so it is impossible to access
 175 // incorrectly from the wrong thread.
 176 base::LazyInstance<base::ThreadLocalPointer<RenderThreadImpl> >
 177     lazy_tls = LAZY_INSTANCE_INITIALIZER;
 178
 179 class RenderViewZoomer : public RenderViewVisitor {
 180  public:
 181   RenderViewZoomer(const std::string& scheme,
 182                    const std::string& host,
 183                    double zoom_level) : scheme_(scheme),
 184                                         host_(host),
 185                                         zoom_level_(zoom_level) {
 186   }
 187
 188   virtual bool Visit(RenderView* render_view) OVERRIDE {
 189     WebView* webview = render_view->GetWebView();
 190     WebDocument document = webview->mainFrame()->document();
 191
 192     // Don't set zoom level for full-page plugin since they don't use the same
 193     // zoom settings.
 194     if (document.isPluginDocument())
 195       return true;
 196     GURL url(document.url());
 197     // Empty scheme works as wildcard that matches any scheme,
 198     if ((net::GetHostOrSpecFromURL(url) == host_) &&
 199         (scheme_.empty() || scheme_ == url.scheme())) {
 200       webview->setZoomLevel(zoom_level_);
 201     }
 202     return true;
 203   }
 204
 205  private:
 206   const std::string scheme_;
 207   const std::string host_;
 208   const double zoom_level_;
 209
 210   DISALLOW_COPY_AND_ASSIGN(RenderViewZoomer);
 211 };
 212
 213 std::string HostToCustomHistogramSuffix(const std::string& host) {
 214   if (host == "mail.google.com")
 215     return ".gmail";
 216   if (host == "docs.google.com" || host == "drive.google.com")
 217     return ".docs";
 218   if (host == "plus.google.com")
 219     return ".plus";
 220   return std::string();
 221 }
 222
 223 void* CreateHistogram(
 224     const char *name, int min, int max, size_t buckets) {
 225   if (min <= 0)
 226     min = 1;
 227   std::string histogram_name;
 228   RenderThreadImpl* render_thread_impl = RenderThreadImpl::current();
 229   if (render_thread_impl) {  // Can be null in tests.
 230     histogram_name = render_thread_impl->
 231         histogram_customizer()->ConvertToCustomHistogramName(name);
 232   } else {
 233     histogram_name = std::string(name);
 234   }
 235   base::HistogramBase* histogram = base::Histogram::FactoryGet(
 236       histogram_name, min, max, buckets,
 237       base::Histogram::kUmaTargetedHistogramFlag);
 238   return histogram;
 239 }
 240
 241 void AddHistogramSample(void* hist, int sample) {
 242   base::Histogram* histogram = static_cast<base::Histogram*>(hist);
 243   histogram->Add(sample);
 244 }
 245
 246 scoped_ptr<base::SharedMemory> AllocateSharedMemoryFunction(size_t size) {
 247   return RenderThreadImpl::Get()->HostAllocateSharedMemoryBuffer(size);
 248 }
 249
 250 void EnableBlinkPlatformLogChannels(const std::string& channels) {
 251   if (channels.empty())
 252     return;
 253   base::StringTokenizer t(channels, ", ");
 254   while (t.GetNext())
 255     blink::enableLogChannel(t.token().c_str());
 256 }
 257
 258 void NotifyTimezoneChangeOnThisThread() {
 259   v8::Isolate* isolate = v8::Isolate::GetCurrent();
 260   if (!isolate)
 261     return;
 262   v8::Date::DateTimeConfigurationChangeNotification(isolate);
 263 }
 264
 265 }  // namespace
 266
 267 RenderThreadImpl::HistogramCustomizer::HistogramCustomizer() {
 268   custom_histograms_.insert("V8.MemoryExternalFragmentationTotal");
 269   custom_histograms_.insert("V8.MemoryHeapSampleTotalCommitted");
 270   custom_histograms_.insert("V8.MemoryHeapSampleTotalUsed");
 271 }
 272
 273 RenderThreadImpl::HistogramCustomizer::~HistogramCustomizer() {}
 274
 275 void RenderThreadImpl::HistogramCustomizer::RenderViewNavigatedToHost(
 276     const std::string& host, size_t view_count) {
 277   if (CommandLine::ForCurrentProcess()->HasSwitch(
 278       switches::kDisableHistogramCustomizer)) {
 279     return;
 280   }
 281   // Check if all RenderViews are displaying a page from the same host. If there
 282   // is only one RenderView, the common host is this view's host. If there are
 283   // many, check if this one shares the common host of the other
 284   // RenderViews. It's ok to not detect some cases where the RenderViews share a
 285   // common host. This information is only used for producing custom histograms.
 286   if (view_count == 1)
 287     SetCommonHost(host);
 288   else if (host != common_host_)
 289     SetCommonHost(std::string());
 290 }
 291
 292 std::string RenderThreadImpl::HistogramCustomizer::ConvertToCustomHistogramName(
 293     const char* histogram_name) const {
 294   std::string name(histogram_name);
 295   if (!common_host_histogram_suffix_.empty() &&
 296       custom_histograms_.find(name) != custom_histograms_.end())
 297     name += common_host_histogram_suffix_;
 298   return name;
 299 }
 300
 301 void RenderThreadImpl::HistogramCustomizer::SetCommonHost(
 302     const std::string& host) {
 303   if (host != common_host_) {
 304     common_host_ = host;
 305     common_host_histogram_suffix_ = HostToCustomHistogramSuffix(host);
 306     v8::V8::SetCreateHistogramFunction(CreateHistogram);
 307   }
 308 }
 309
 310 RenderThreadImpl* RenderThreadImpl::current() {
 311   return lazy_tls.Pointer()->Get();
 312 }
 313
 314 // When we run plugins in process, we actually run them on the render thread,
 315 // which means that we need to make the render thread pump UI events.
 316 RenderThreadImpl::RenderThreadImpl() {
 317   Init();
 318 }
 319
 320 RenderThreadImpl::RenderThreadImpl(const std::string& channel_name)
 321     : ChildThread(channel_name) {
 322   Init();
 323 }
 324
 325 void RenderThreadImpl::Init() {
 326   TRACE_EVENT_BEGIN_ETW("RenderThreadImpl::Init", 0, "");
 327
 328   base::debug::TraceLog::GetInstance()->SetThreadSortIndex(
 329       base::PlatformThread::CurrentId(),
 330       kTraceEventRendererMainThreadSortIndex);
 331
 332   v8::V8::SetCounterFunction(base::StatsTable::FindLocation);
 333   v8::V8::SetCreateHistogramFunction(CreateHistogram);
 334   v8::V8::SetAddHistogramSampleFunction(AddHistogramSample);
 335
 336 #if defined(OS_MACOSX) || defined(OS_ANDROID)
 337   // On Mac and Android, the select popups are rendered by the browser.
 338   blink::WebView::setUseExternalPopupMenus(true);
 339 #endif
 340
 341   lazy_tls.Pointer()->Set(this);
 342
 343   // Register this object as the main thread.
 344   ChildProcess::current()->set_main_thread(this);
 345
 346   // In single process the single process is all there is.
 347   suspend_webkit_shared_timer_ = true;
 348   notify_webkit_of_modal_loop_ = true;
 349   webkit_shared_timer_suspended_ = false;
 350   widget_count_ = 0;
 351   hidden_widget_count_ = 0;
 352   idle_notification_delay_in_ms_ = kInitialIdleHandlerDelayMs;
 353   idle_notifications_to_skip_ = 0;
 354   layout_test_mode_ = false;
 355
 356   appcache_dispatcher_.reset(
 357       new AppCacheDispatcher(Get(), new AppCacheFrontendImpl()));
 358   dom_storage_dispatcher_.reset(new DomStorageDispatcher());
 359   main_thread_indexed_db_dispatcher_.reset(new IndexedDBDispatcher(
 360       thread_safe_sender()));
 361   embedded_worker_dispatcher_.reset(new EmbeddedWorkerDispatcher());
 362
 363   media_stream_center_ = NULL;
 364
 365   db_message_filter_ = new DBMessageFilter();
 366   AddFilter(db_message_filter_.get());
 367
 368   vc_manager_.reset(new VideoCaptureImplManager());
 369   AddFilter(vc_manager_->video_capture_message_filter());
 370
 371 #if defined(ENABLE_WEBRTC)
 372   peer_connection_tracker_.reset(new PeerConnectionTracker());
 373   AddObserver(peer_connection_tracker_.get());
 374
 375   p2p_socket_dispatcher_ =
 376       new P2PSocketDispatcher(GetIOMessageLoopProxy().get());
 377   AddFilter(p2p_socket_dispatcher_.get());
 378
 379   webrtc_identity_service_.reset(new WebRTCIdentityService());
 380
 381   media_stream_factory_.reset(new MediaStreamDependencyFactory(
 382       p2p_socket_dispatcher_.get()));
 383   AddObserver(media_stream_factory_.get());
 384 #endif  // defined(ENABLE_WEBRTC)
 385
 386   audio_input_message_filter_ =
 387       new AudioInputMessageFilter(GetIOMessageLoopProxy());
 388   AddFilter(audio_input_message_filter_.get());
 389
 390   audio_message_filter_ = new AudioMessageFilter(GetIOMessageLoopProxy());
 391   AddFilter(audio_message_filter_.get());
 392
 393   midi_message_filter_ = new MidiMessageFilter(GetIOMessageLoopProxy());
 394   AddFilter(midi_message_filter_.get());
 395
 396   AddFilter((new IndexedDBMessageFilter(thread_safe_sender()))->GetFilter());
 397
 398   AddFilter((new EmbeddedWorkerContextMessageFilter())->GetFilter());
 399
 400 #if defined(USE_MOJO)
 401   // MojoRenderProcessObserver deletes itself as necessary.
 402   new MojoRenderProcessObserver(this);
 403 #endif
 404
 405   GetContentClient()->renderer()->RenderThreadStarted();
 406
 407   InitSkiaEventTracer();
 408
 409   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
 410   if (command_line.HasSwitch(cc::switches::kEnableGpuBenchmarking))
 411       RegisterExtension(GpuBenchmarkingExtension::Get());
 412
 413   is_impl_side_painting_enabled_ =
 414       command_line.HasSwitch(switches::kEnableImplSidePainting) &&
 415       !command_line.HasSwitch(switches::kDisableImplSidePainting);
 416   webkit::WebLayerImpl::SetImplSidePaintingEnabled(
 417       is_impl_side_painting_enabled_);
 418
 419   is_map_image_enabled_ =
 420       command_line.HasSwitch(switches::kEnableMapImage) &&
 421       !command_line.HasSwitch(switches::kDisableMapImage);
 422
 423   if (command_line.HasSwitch(switches::kDisableLCDText)) {
 424     is_lcd_text_enabled_ = false;
 425   } else if (command_line.HasSwitch(switches::kEnableLCDText)) {
 426     is_lcd_text_enabled_ = true;
 427   } else {
 428 #if defined(OS_ANDROID)
 429     is_lcd_text_enabled_ = false;
 430 #else
 431     is_lcd_text_enabled_ = true;
 432 #endif
 433   }
 434
 435   is_gpu_rasterization_enabled_ = false;
 436   is_gpu_rasterization_forced_ = false;
 437   if (is_impl_side_painting_enabled_ &&
 438       !command_line.HasSwitch(switches::kDisableGpuRasterization)) {
 439     if (command_line.HasSwitch(switches::kForceGpuRasterization)) {
 440       is_gpu_rasterization_forced_ = true;
 441     } else if (command_line.HasSwitch(switches::kEnableGpuRasterization) ||
 442                command_line.HasSwitch(
 443                    switches::kEnableBleedingEdgeRenderingFastPaths)) {
 444       is_gpu_rasterization_enabled_ = true;
 445     }
 446   }
 447
 448   is_low_res_tiling_enabled_ = true;
 449   if (command_line.HasSwitch(switches::kDisableLowResTiling) &&
 450       !command_line.HasSwitch(switches::kEnableLowResTiling)) {
 451     is_low_res_tiling_enabled_ = false;
 452   }
 453
 454   // Note that under Linux, the media library will normally already have
 455   // been initialized by the Zygote before this instance became a Renderer.
 456   base::FilePath media_path;
 457   PathService::Get(DIR_MEDIA_LIBS, &media_path);
 458   if (!media_path.empty())
 459     media::InitializeMediaLibrary(media_path);
 460
 461   memory_pressure_listener_.reset(new base::MemoryPressureListener(
 462       base::Bind(&RenderThreadImpl::OnMemoryPressure, base::Unretained(this))));
 463
 464   std::vector<base::DiscardableMemoryType> supported_types;
 465   base::DiscardableMemory::GetSupportedTypes(&supported_types);
 466   DCHECK(!supported_types.empty());
 467
 468   // The default preferred type is always the first one in list.
 469   base::DiscardableMemoryType type = supported_types[0];
 470
 471   if (command_line.HasSwitch(switches::kUseDiscardableMemory)) {
 472     std::string requested_type_name = command_line.GetSwitchValueASCII(
 473         switches::kUseDiscardableMemory);
 474     base::DiscardableMemoryType requested_type =
 475         base::DiscardableMemory::GetNamedType(requested_type_name);
 476     if (std::find(supported_types.begin(),
 477                   supported_types.end(),
 478                   requested_type) != supported_types.end()) {
 479       type = requested_type;
 480     } else {
 481       LOG(ERROR) << "Requested discardable memory type is not supported.";
 482     }
 483   }
 484
 485   base::DiscardableMemory::SetPreferredType(type);
 486
 487   // Allow discardable memory implementations to register memory pressure
 488   // listeners.
 489   base::DiscardableMemory::RegisterMemoryPressureListeners();
 490
 491   // AllocateGpuMemoryBuffer must be used exclusively on one thread but
 492   // it doesn't have to be the same thread RenderThreadImpl is created on.
 493   allocate_gpu_memory_buffer_thread_checker_.DetachFromThread();
 494
 495   if (command_line.HasSwitch(switches::kNumRasterThreads)) {
 496     int num_raster_threads;
 497     std::string string_value =
 498         command_line.GetSwitchValueASCII(switches::kNumRasterThreads);
 499     if (base::StringToInt(string_value, &num_raster_threads) &&
 500         num_raster_threads >= kMinRasterThreads &&
 501         num_raster_threads <= kMaxRasterThreads) {
 502       cc::RasterWorkerPool::SetNumRasterThreads(num_raster_threads);
 503     } else {
 504       LOG(WARNING) << "Failed to parse switch " <<
 505                       switches::kNumRasterThreads  << ": " << string_value;
 506     }
 507   }
 508
 509   TRACE_EVENT_END_ETW("RenderThreadImpl::Init", 0, "");
 510 }
 511
 512 RenderThreadImpl::~RenderThreadImpl() {
 513 }
 514
 515 void RenderThreadImpl::Shutdown() {
 516   FOR_EACH_OBSERVER(
 517       RenderProcessObserver, observers_, OnRenderProcessShutdown());
 518
 519   ChildThread::Shutdown();
 520
 521   // Wait for all databases to be closed.
 522   if (webkit_platform_support_) {
 523     webkit_platform_support_->web_database_observer_impl()->
 524         WaitForAllDatabasesToClose();
 525   }
 526
 527   // Shutdown in reverse of the initialization order.
 528   if (devtools_agent_message_filter_.get()) {
 529     RemoveFilter(devtools_agent_message_filter_.get());
 530     devtools_agent_message_filter_ = NULL;
 531   }
 532
 533   RemoveFilter(audio_input_message_filter_.get());
 534   audio_input_message_filter_ = NULL;
 535
 536   RemoveFilter(audio_message_filter_.get());
 537   audio_message_filter_ = NULL;
 538
 539   // |media_stream_factory_| produces users of |vc_manager_| so it must be
 540   // destroyed first.
 541 #if defined(ENABLE_WEBRTC)
 542   media_stream_factory_.reset();
 543 #endif
 544   RemoveFilter(vc_manager_->video_capture_message_filter());
 545   vc_manager_.reset();
 546
 547   RemoveFilter(db_message_filter_.get());
 548   db_message_filter_ = NULL;
 549
 550   // Shutdown the file thread if it's running.
 551   if (file_thread_)
 552     file_thread_->Stop();
 553
 554   if (compositor_output_surface_filter_.get()) {
 555     RemoveFilter(compositor_output_surface_filter_.get());
 556     compositor_output_surface_filter_ = NULL;
 557   }
 558
 559   media_thread_.reset();
 560   compositor_thread_.reset();
 561   input_handler_manager_.reset();
 562   if (input_event_filter_.get()) {
 563     RemoveFilter(input_event_filter_.get());
 564     input_event_filter_ = NULL;
 565   }
 566
 567   // Ramp down IDB before we ramp down WebKit (and V8), since IDB classes might
 568   // hold pointers to V8 objects (e.g., via pending requests).
 569   main_thread_indexed_db_dispatcher_.reset();
 570
 571   if (webkit_platform_support_)
 572     blink::shutdown();
 573
 574   lazy_tls.Pointer()->Set(NULL);
 575
 576   // TODO(port)
 577 #if defined(OS_WIN)
 578   // Clean up plugin channels before this thread goes away.
 579   NPChannelBase::CleanupChannels();
 580 #endif
 581
 582   // Leak shared contexts on other threads, as we can not get to the correct
 583   // thread to destroy them.
 584   if (offscreen_compositor_contexts_.get())
 585     offscreen_compositor_contexts_->set_leak_on_destroy();
 586 }
 587
 588 bool RenderThreadImpl::Send(IPC::Message* msg) {
 589   // Certain synchronous messages cannot always be processed synchronously by
 590   // the browser, e.g., putting up UI and waiting for the user. This could cause
 591   // a complete hang of Chrome if a windowed plug-in is trying to communicate
 592   // with the renderer thread since the browser's UI thread could be stuck
 593   // (within a Windows API call) trying to synchronously communicate with the
 594   // plug-in.  The remedy is to pump messages on this thread while the browser
 595   // is processing this request. This creates an opportunity for re-entrancy
 596   // into WebKit, so we need to take care to disable callbacks, timers, and
 597   // pending network loads that could trigger such callbacks.
 598   bool pumping_events = false;
 599   if (msg->is_sync()) {
 600     if (msg->is_caller_pumping_messages()) {
 601       pumping_events = true;
 602     }
 603   }
 604
 605   bool suspend_webkit_shared_timer = true;  // default value
 606   std::swap(suspend_webkit_shared_timer, suspend_webkit_shared_timer_);
 607
 608   bool notify_webkit_of_modal_loop = true;  // default value
 609   std::swap(notify_webkit_of_modal_loop, notify_webkit_of_modal_loop_);
 610
 611 #if defined(ENABLE_PLUGINS)
 612   int render_view_id = MSG_ROUTING_NONE;
 613 #endif
 614
 615   if (pumping_events) {
 616     if (suspend_webkit_shared_timer)
 617       webkit_platform_support_->SuspendSharedTimer();
 618
 619     if (notify_webkit_of_modal_loop)
 620       WebView::willEnterModalLoop();
 621 #if defined(ENABLE_PLUGINS)
 622     RenderViewImpl* render_view =
 623         RenderViewImpl::FromRoutingID(msg->routing_id());
 624     if (render_view) {
 625       render_view_id = msg->routing_id();
 626       PluginChannelHost::Broadcast(
 627           new PluginMsg_SignalModalDialogEvent(render_view_id));
 628     }
 629 #endif
 630   }
 631
 632   bool rv = ChildThread::Send(msg);
 633
 634   if (pumping_events) {
 635 #if defined(ENABLE_PLUGINS)
 636     if (render_view_id != MSG_ROUTING_NONE) {
 637       PluginChannelHost::Broadcast(
 638           new PluginMsg_ResetModalDialogEvent(render_view_id));
 639     }
 640 #endif
 641
 642     if (notify_webkit_of_modal_loop)
 643       WebView::didExitModalLoop();
 644
 645     if (suspend_webkit_shared_timer)
 646       webkit_platform_support_->ResumeSharedTimer();
 647   }
 648
 649   return rv;
 650 }
 651
 652 base::MessageLoop* RenderThreadImpl::GetMessageLoop() {
 653   return message_loop();
 654 }
 655
 656 IPC::SyncChannel* RenderThreadImpl::GetChannel() {
 657   return channel();
 658 }
 659
 660 std::string RenderThreadImpl::GetLocale() {
 661   // The browser process should have passed the locale to the renderer via the
 662   // --lang command line flag.
 663   const CommandLine& parsed_command_line = *CommandLine::ForCurrentProcess();
 664   const std::string& lang =
 665       parsed_command_line.GetSwitchValueASCII(switches::kLang);
 666   DCHECK(!lang.empty());
 667   return lang;
 668 }
 669
 670 IPC::SyncMessageFilter* RenderThreadImpl::GetSyncMessageFilter() {
 671   return sync_message_filter();
 672 }
 673
 674 scoped_refptr<base::MessageLoopProxy>
 675     RenderThreadImpl::GetIOMessageLoopProxy() {
 676   return ChildProcess::current()->io_message_loop_proxy();
 677 }
 678
 679 void RenderThreadImpl::AddRoute(int32 routing_id, IPC::Listener* listener) {
 680   ChildThread::GetRouter()->AddRoute(routing_id, listener);
 681 }
 682
 683 void RenderThreadImpl::RemoveRoute(int32 routing_id) {
 684   ChildThread::GetRouter()->RemoveRoute(routing_id);
 685 }
 686
 687 void RenderThreadImpl::AddSharedWorkerRoute(int32 routing_id,
 688                                             IPC::Listener* listener) {
 689   AddRoute(routing_id, listener);
 690   if (devtools_agent_message_filter_.get()) {
 691     devtools_agent_message_filter_->AddSharedWorkerRouteOnMainThread(
 692         routing_id);
 693   }
 694 }
 695
 696 void RenderThreadImpl::RemoveSharedWorkerRoute(int32 routing_id) {
 697   RemoveRoute(routing_id);
 698   if (devtools_agent_message_filter_.get()) {
 699     devtools_agent_message_filter_->RemoveSharedWorkerRouteOnMainThread(
 700         routing_id);
 701   }
 702 }
 703
 704 int RenderThreadImpl::GenerateRoutingID() {
 705   int routing_id = MSG_ROUTING_NONE;
 706   Send(new ViewHostMsg_GenerateRoutingID(&routing_id));
 707   return routing_id;
 708 }
 709
 710 void RenderThreadImpl::AddFilter(IPC::ChannelProxy::MessageFilter* filter) {
 711   channel()->AddFilter(filter);
 712 }
 713
 714 void RenderThreadImpl::RemoveFilter(IPC::ChannelProxy::MessageFilter* filter) {
 715   channel()->RemoveFilter(filter);
 716 }
 717
 718 void RenderThreadImpl::AddObserver(RenderProcessObserver* observer) {
 719   observers_.AddObserver(observer);
 720 }
 721
 722 void RenderThreadImpl::RemoveObserver(RenderProcessObserver* observer) {
 723   observers_.RemoveObserver(observer);
 724 }
 725
 726 void RenderThreadImpl::SetResourceDispatcherDelegate(
 727     ResourceDispatcherDelegate* delegate) {
 728   resource_dispatcher()->set_delegate(delegate);
 729 }
 730
 731 void RenderThreadImpl::EnsureWebKitInitialized() {
 732   if (webkit_platform_support_)
 733     return;
 734
 735   webkit_platform_support_.reset(new RendererWebKitPlatformSupportImpl);
 736   blink::initialize(webkit_platform_support_.get());
 737
 738   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
 739
 740   bool enable = command_line.HasSwitch(switches::kEnableThreadedCompositing);
 741   if (enable) {
 742 #if defined(OS_ANDROID)
 743     if (SynchronousCompositorFactory* factory =
 744         SynchronousCompositorFactory::GetInstance())
 745       compositor_message_loop_proxy_ =
 746           factory->GetCompositorMessageLoop();
 747 #endif
 748     if (!compositor_message_loop_proxy_.get()) {
 749       compositor_thread_.reset(new base::Thread("Compositor"));
 750       compositor_thread_->Start();
 751 #if defined(OS_ANDROID)
 752       compositor_thread_->SetPriority(base::kThreadPriority_Display);
 753 #endif
 754       compositor_message_loop_proxy_ =
 755           compositor_thread_->message_loop_proxy();
 756       compositor_message_loop_proxy_->PostTask(
 757           FROM_HERE,
 758           base::Bind(base::IgnoreResult(&ThreadRestrictions::SetIOAllowed),
 759                      false));
 760     }
 761
 762     InputHandlerManagerClient* input_handler_manager_client = NULL;
 763 #if defined(OS_ANDROID)
 764     if (SynchronousCompositorFactory* factory =
 765         SynchronousCompositorFactory::GetInstance()) {
 766       input_handler_manager_client = factory->GetInputHandlerManagerClient();
 767     }
 768 #endif
 769     if (!input_handler_manager_client) {
 770       input_event_filter_ =
 771           new InputEventFilter(this, compositor_message_loop_proxy_);
 772       AddFilter(input_event_filter_.get());
 773       input_handler_manager_client = input_event_filter_.get();
 774     }
 775     input_handler_manager_.reset(
 776         new InputHandlerManager(compositor_message_loop_proxy_,
 777                                 input_handler_manager_client));
 778   }
 779
 780   scoped_refptr<base::MessageLoopProxy> output_surface_loop;
 781   if (enable)
 782     output_surface_loop = compositor_message_loop_proxy_;
 783   else
 784     output_surface_loop = base::MessageLoopProxy::current();
 785
 786   compositor_output_surface_filter_ =
 787       CompositorOutputSurface::CreateFilter(output_surface_loop.get());
 788   AddFilter(compositor_output_surface_filter_.get());
 789
 790   RenderThreadImpl::RegisterSchemes();
 791
 792   EnableBlinkPlatformLogChannels(
 793       command_line.GetSwitchValueASCII(switches::kBlinkPlatformLogChannels));
 794
 795   SetRuntimeFeaturesDefaultsAndUpdateFromArgs(command_line);
 796
 797   if (!media::IsMediaLibraryInitialized()) {
 798     WebRuntimeFeatures::enableMediaPlayer(false);
 799     WebRuntimeFeatures::enableWebAudio(false);
 800   }
 801
 802   FOR_EACH_OBSERVER(RenderProcessObserver, observers_, WebKitInitialized());
 803
 804   devtools_agent_message_filter_ = new DevToolsAgentFilter();
 805   AddFilter(devtools_agent_message_filter_.get());
 806
 807   if (GetContentClient()->renderer()->RunIdleHandlerWhenWidgetsHidden())
 808     ScheduleIdleHandler(kLongIdleHandlerDelayMs);
 809
 810   webkit::SetSharedMemoryAllocationFunction(AllocateSharedMemoryFunction);
 811
 812   // Limit use of the scaled image cache to when deferred image decoding
 813   // is enabled.
 814   // TODO(reveman): Allow use of this cache on Android once
 815   // SkDiscardablePixelRef is used for decoded images. crbug.com/330041
 816   bool use_skia_scaled_image_cache = false;
 817 #if !defined(OS_ANDROID)
 818   use_skia_scaled_image_cache =
 819       command_line.HasSwitch(switches::kEnableDeferredImageDecoding) ||
 820       is_impl_side_painting_enabled_;
 821 #endif
 822   if (!use_skia_scaled_image_cache)
 823     SkGraphics::SetImageCacheByteLimit(0u);
 824 }
 825
 826 void RenderThreadImpl::RegisterSchemes() {
 827   // swappedout: pages should not be accessible, and should also
 828   // be treated as empty documents that can commit synchronously.
 829   WebString swappedout_scheme(base::ASCIIToUTF16(kSwappedOutScheme));
 830   WebSecurityPolicy::registerURLSchemeAsDisplayIsolated(swappedout_scheme);
 831   WebSecurityPolicy::registerURLSchemeAsEmptyDocument(swappedout_scheme);
 832 }
 833
 834 void RenderThreadImpl::NotifyTimezoneChange() {
 835   NotifyTimezoneChangeOnThisThread();
 836   RenderThread::Get()->PostTaskToAllWebWorkers(
 837       base::Bind(&NotifyTimezoneChangeOnThisThread));
 838 }
 839
 840 void RenderThreadImpl::RecordAction(const base::UserMetricsAction& action) {
 841   Send(new ViewHostMsg_UserMetricsRecordAction(action.str_));
 842 }
 843
 844 void RenderThreadImpl::RecordComputedAction(const std::string& action) {
 845   Send(new ViewHostMsg_UserMetricsRecordAction(action));
 846 }
 847
 848 scoped_ptr<base::SharedMemory>
 849     RenderThreadImpl::HostAllocateSharedMemoryBuffer(size_t size) {
 850   if (size > static_cast<size_t>(std::numeric_limits<int>::max()))
 851     return scoped_ptr<base::SharedMemory>();
 852
 853   base::SharedMemoryHandle handle;
 854   bool success;
 855   IPC::Message* message =
 856       new ChildProcessHostMsg_SyncAllocateSharedMemory(size, &handle);
 857
 858   // Allow calling this from the compositor thread.
 859   if (base::MessageLoop::current() == message_loop())
 860     success = ChildThread::Send(message);
 861   else
 862     success = sync_message_filter()->Send(message);
 863
 864   if (!success)
 865     return scoped_ptr<base::SharedMemory>();
 866
 867   if (!base::SharedMemory::IsHandleValid(handle))
 868     return scoped_ptr<base::SharedMemory>();
 869
 870   return scoped_ptr<base::SharedMemory>(new base::SharedMemory(handle, false));
 871 }
 872
 873 void RenderThreadImpl::RegisterExtension(v8::Extension* extension) {
 874   WebScriptController::registerExtension(extension);
 875 }
 876
 877 void RenderThreadImpl::ScheduleIdleHandler(int64 initial_delay_ms) {
 878   idle_notification_delay_in_ms_ = initial_delay_ms;
 879   idle_timer_.Stop();
 880   idle_timer_.Start(FROM_HERE,
 881       base::TimeDelta::FromMilliseconds(initial_delay_ms),
 882       this, &RenderThreadImpl::IdleHandler);
 883 }
 884
 885 void RenderThreadImpl::IdleHandler() {
 886   bool run_in_foreground_tab = (widget_count_ > hidden_widget_count_) &&
 887                                GetContentClient()->renderer()->
 888                                    RunIdleHandlerWhenWidgetsHidden();
 889   if (run_in_foreground_tab) {
 890     IdleHandlerInForegroundTab();
 891     return;
 892   }
 893
 894   base::allocator::ReleaseFreeMemory();
 895
 896   // Continue the idle timer if the webkit shared timer is not suspended or
 897   // something is left to do.
 898   bool continue_timer = !webkit_shared_timer_suspended_;
 899
 900   if (!v8::V8::IdleNotification()) {
 901     continue_timer = true;
 902   }
 903
 904   // Schedule next invocation.
 905   // Dampen the delay using the algorithm (if delay is in seconds):
 906   //    delay = delay + 1 / (delay + 2)
 907   // Using floor(delay) has a dampening effect such as:
 908   //    1s, 1, 1, 2, 2, 2, 2, 3, 3, ...
 909   // If the delay is in milliseconds, the above formula is equivalent to:
 910   //    delay_ms / 1000 = delay_ms / 1000 + 1 / (delay_ms / 1000 + 2)
 911   // which is equivalent to
 912   //    delay_ms = delay_ms + 1000*1000 / (delay_ms + 2000).
 913   // Note that idle_notification_delay_in_ms_ would be reset to
 914   // kInitialIdleHandlerDelayMs in RenderThreadImpl::WidgetHidden.
 915   if (continue_timer) {
 916     ScheduleIdleHandler(idle_notification_delay_in_ms_ +
 917                         1000000 / (idle_notification_delay_in_ms_ + 2000));
 918
 919   } else {
 920     idle_timer_.Stop();
 921   }
 922
 923   FOR_EACH_OBSERVER(RenderProcessObserver, observers_, IdleNotification());
 924 }
 925
 926 void RenderThreadImpl::IdleHandlerInForegroundTab() {
 927   // Increase the delay in the same way as in IdleHandler,
 928   // but make it periodic by reseting it once it is too big.
 929   int64 new_delay_ms = idle_notification_delay_in_ms_ +
 930                        1000000 / (idle_notification_delay_in_ms_ + 2000);
 931   if (new_delay_ms >= kLongIdleHandlerDelayMs)
 932     new_delay_ms = kShortIdleHandlerDelayMs;
 933
 934   if (idle_notifications_to_skip_ > 0) {
 935     idle_notifications_to_skip_--;
 936   } else  {
 937     int cpu_usage = 0;
 938     Send(new ViewHostMsg_GetCPUUsage(&cpu_usage));
 939     // Idle notification hint roughly specifies the expected duration of the
 940     // idle pause. We set it proportional to the idle timer delay.
 941     int idle_hint = static_cast<int>(new_delay_ms / 10);
 942     if (cpu_usage < kIdleCPUUsageThresholdInPercents) {
 943       base::allocator::ReleaseFreeMemory();
 944       if (v8::V8::IdleNotification(idle_hint)) {
 945         // V8 finished collecting garbage.
 946         new_delay_ms = kLongIdleHandlerDelayMs;
 947       }
 948     }
 949   }
 950   ScheduleIdleHandler(new_delay_ms);
 951 }
 952
 953 int64 RenderThreadImpl::GetIdleNotificationDelayInMs() const {
 954   return idle_notification_delay_in_ms_;
 955 }
 956
 957 void RenderThreadImpl::SetIdleNotificationDelayInMs(
 958     int64 idle_notification_delay_in_ms) {
 959   idle_notification_delay_in_ms_ = idle_notification_delay_in_ms;
 960 }
 961
 962 void RenderThreadImpl::UpdateHistograms(int sequence_number) {
 963   child_histogram_message_filter()->SendHistograms(sequence_number);
 964 }
 965
 966 int RenderThreadImpl::PostTaskToAllWebWorkers(const base::Closure& closure) {
 967   return WorkerTaskRunner::Instance()->PostTaskToAllThreads(closure);
 968 }
 969
 970 bool RenderThreadImpl::ResolveProxy(const GURL& url, std::string* proxy_list) {
 971   bool result = false;
 972   Send(new ViewHostMsg_ResolveProxy(url, &result, proxy_list));
 973   return result;
 974 }
 975
 976 void RenderThreadImpl::PostponeIdleNotification() {
 977   idle_notifications_to_skip_ = 2;
 978 }
 979
 980 scoped_refptr<media::GpuVideoAcceleratorFactories>
 981 RenderThreadImpl::GetGpuFactories() {
 982   DCHECK(IsMainThread());
 983
 984   scoped_refptr<GpuChannelHost> gpu_channel_host = GetGpuChannel();
 985   const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
 986   scoped_refptr<media::GpuVideoAcceleratorFactories> gpu_factories;
 987   scoped_refptr<base::MessageLoopProxy> media_loop_proxy =
 988       GetMediaThreadMessageLoopProxy();
 989   if (!cmd_line->HasSwitch(switches::kDisableAcceleratedVideoDecode)) {
 990     if (!gpu_va_context_provider_ ||
 991         gpu_va_context_provider_->DestroyedOnMainThread()) {
 992       if (!gpu_channel_host) {
 993         gpu_channel_host = EstablishGpuChannelSync(
 994             CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE);
 995       }
 996       gpu_va_context_provider_ = ContextProviderCommandBuffer::Create(
 997           make_scoped_ptr(
 998               WebGraphicsContext3DCommandBufferImpl::CreateOffscreenContext(
 999                   gpu_channel_host.get(),
1000                   blink::WebGraphicsContext3D::Attributes(),
1001                   GURL("chrome://gpu/RenderThreadImpl::GetGpuVDAContext3D"),
1002                   WebGraphicsContext3DCommandBufferImpl::SharedMemoryLimits(),
1003                   NULL)),
1004           "GPU-VideoAccelerator-Offscreen");
1005     }
1006   }
1007   if (gpu_va_context_provider_) {
1008     gpu_factories = RendererGpuVideoAcceleratorFactories::Create(
1009         gpu_channel_host, media_loop_proxy, gpu_va_context_provider_);
1010   }
1011   return gpu_factories;
1012 }
1013
1014 scoped_ptr<WebGraphicsContext3DCommandBufferImpl>
1015 RenderThreadImpl::CreateOffscreenContext3d() {
1016   blink::WebGraphicsContext3D::Attributes attributes;
1017   attributes.shareResources = true;
1018   attributes.depth = false;
1019   attributes.stencil = false;
1020   attributes.antialias = false;
1021   attributes.noAutomaticFlushes = true;
1022
1023   scoped_refptr<GpuChannelHost> gpu_channel_host(EstablishGpuChannelSync(
1024       CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE));
1025   return make_scoped_ptr(
1026       WebGraphicsContext3DCommandBufferImpl::CreateOffscreenContext(
1027           gpu_channel_host.get(),
1028           attributes,
1029           GURL("chrome://gpu/RenderThreadImpl::CreateOffscreenContext3d"),
1030           WebGraphicsContext3DCommandBufferImpl::SharedMemoryLimits(),
1031           NULL));
1032 }
1033
1034 scoped_refptr<cc::ContextProvider>
1035 RenderThreadImpl::OffscreenCompositorContextProvider() {
1036   DCHECK(IsMainThread());
1037
1038 #if defined(OS_ANDROID)
1039   if (SynchronousCompositorFactory* factory =
1040       SynchronousCompositorFactory::GetInstance()) {
1041     if (compositor_message_loop_proxy_)
1042       return factory->GetOffscreenContextProviderForCompositorThread();
1043     return factory->GetOffscreenContextProviderForMainThread();
1044   }
1045 #endif
1046
1047   if (!offscreen_compositor_contexts_.get() ||
1048       offscreen_compositor_contexts_->DestroyedOnMainThread()) {
1049     offscreen_compositor_contexts_ = ContextProviderCommandBuffer::Create(
1050         CreateOffscreenContext3d(),
1051         "Compositor-Offscreen");
1052   }
1053   return offscreen_compositor_contexts_;
1054 }
1055
1056 scoped_refptr<webkit::gpu::ContextProviderWebContext>
1057 RenderThreadImpl::SharedMainThreadContextProvider() {
1058   DCHECK(IsMainThread());
1059 #if defined(OS_ANDROID)
1060   if (SynchronousCompositorFactory* factory =
1061       SynchronousCompositorFactory::GetInstance())
1062     return factory->GetOffscreenContextProviderForMainThread();
1063 #endif
1064
1065   if (!shared_main_thread_contexts_ ||
1066       shared_main_thread_contexts_->DestroyedOnMainThread()) {
1067     if (compositor_message_loop_proxy_) {
1068       // In threaded compositing mode, we have to create a new ContextProvider
1069       // to bind to the main thread since the compositor's is bound to the
1070       // compositor thread.
1071       shared_main_thread_contexts_ =
1072           ContextProviderCommandBuffer::Create(CreateOffscreenContext3d(),
1073                                                "Offscreen-MainThread");
1074     } else {
1075       // In single threaded mode, we can use the same context provider.
1076       shared_main_thread_contexts_ =
1077           static_cast<ContextProviderCommandBuffer*>(
1078                 OffscreenCompositorContextProvider().get());
1079     }
1080   }
1081   if (shared_main_thread_contexts_ &&
1082       !shared_main_thread_contexts_->BindToCurrentThread())
1083     shared_main_thread_contexts_ = NULL;
1084   return shared_main_thread_contexts_;
1085 }
1086
1087 AudioRendererMixerManager* RenderThreadImpl::GetAudioRendererMixerManager() {
1088   if (!audio_renderer_mixer_manager_) {
1089     audio_renderer_mixer_manager_.reset(new AudioRendererMixerManager(
1090         GetAudioHardwareConfig()));
1091   }
1092
1093   return audio_renderer_mixer_manager_.get();
1094 }
1095
1096 media::AudioHardwareConfig* RenderThreadImpl::GetAudioHardwareConfig() {
1097   if (!audio_hardware_config_) {
1098     media::AudioParameters input_params;
1099     media::AudioParameters output_params;
1100     Send(new ViewHostMsg_GetAudioHardwareConfig(
1101         &input_params, &output_params));
1102
1103     audio_hardware_config_.reset(new media::AudioHardwareConfig(
1104         input_params, output_params));
1105     audio_message_filter_->SetAudioHardwareConfig(audio_hardware_config_.get());
1106   }
1107
1108   return audio_hardware_config_.get();
1109 }
1110
1111 base::WaitableEvent* RenderThreadImpl::GetShutdownEvent() {
1112   return ChildProcess::current()->GetShutDownEvent();
1113 }
1114
1115 #if defined(OS_WIN)
1116 void RenderThreadImpl::PreCacheFontCharacters(const LOGFONT& log_font,
1117                                               const base::string16& str) {
1118   Send(new ViewHostMsg_PreCacheFontCharacters(log_font, str));
1119 }
1120
1121 void RenderThreadImpl::PreCacheFont(const LOGFONT& log_font) {
1122   Send(new ChildProcessHostMsg_PreCacheFont(log_font));
1123 }
1124
1125 void RenderThreadImpl::ReleaseCachedFonts() {
1126   Send(new ChildProcessHostMsg_ReleaseCachedFonts());
1127 }
1128
1129 #endif  // OS_WIN
1130
1131 bool RenderThreadImpl::IsMainThread() {
1132   return !!current();
1133 }
1134
1135 base::MessageLoop* RenderThreadImpl::GetMainLoop() {
1136   return message_loop();
1137 }
1138
1139 scoped_refptr<base::MessageLoopProxy> RenderThreadImpl::GetIOLoopProxy() {
1140   return io_message_loop_proxy_;
1141 }
1142
1143 scoped_ptr<base::SharedMemory> RenderThreadImpl::AllocateSharedMemory(
1144     size_t size) {
1145   return scoped_ptr<base::SharedMemory>(
1146       HostAllocateSharedMemoryBuffer(size));
1147 }
1148
1149 int32 RenderThreadImpl::CreateViewCommandBuffer(
1150       int32 surface_id, const GPUCreateCommandBufferConfig& init_params) {
1151   TRACE_EVENT1("gpu",
1152                "RenderThreadImpl::CreateViewCommandBuffer",
1153                "surface_id",
1154                surface_id);
1155
1156   int32 route_id = MSG_ROUTING_NONE;
1157   IPC::Message* message = new GpuHostMsg_CreateViewCommandBuffer(
1158       surface_id,
1159       init_params,
1160       &route_id);
1161
1162   // Allow calling this from the compositor thread.
1163   thread_safe_sender()->Send(message);
1164
1165   return route_id;
1166 }
1167
1168 void RenderThreadImpl::CreateImage(
1169     gfx::PluginWindowHandle window,
1170     int32 image_id,
1171     const CreateImageCallback& callback) {
1172   NOTREACHED();
1173 }
1174
1175 void RenderThreadImpl::DeleteImage(int32 image_id, int32 sync_point) {
1176   NOTREACHED();
1177 }
1178
1179 scoped_ptr<gfx::GpuMemoryBuffer> RenderThreadImpl::AllocateGpuMemoryBuffer(
1180     size_t width,
1181     size_t height,
1182     unsigned internalformat) {
1183   DCHECK(allocate_gpu_memory_buffer_thread_checker_.CalledOnValidThread());
1184
1185   if (!GpuMemoryBufferImpl::IsFormatValid(internalformat))
1186     return scoped_ptr<gfx::GpuMemoryBuffer>();
1187
1188   gfx::GpuMemoryBufferHandle handle;
1189   bool success;
1190   IPC::Message* message =
1191       new ChildProcessHostMsg_SyncAllocateGpuMemoryBuffer(width,
1192                                                           height,
1193                                                           internalformat,
1194                                                           &handle);
1195
1196   // Allow calling this from the compositor thread.
1197   if (base::MessageLoop::current() == message_loop())
1198     success = ChildThread::Send(message);
1199   else
1200     success = sync_message_filter()->Send(message);
1201
1202   if (!success)
1203     return scoped_ptr<gfx::GpuMemoryBuffer>();
1204
1205   return GpuMemoryBufferImpl::Create(
1206       handle,
1207       gfx::Size(width, height),
1208       internalformat).PassAs<gfx::GpuMemoryBuffer>();
1209 }
1210
1211 void RenderThreadImpl::DoNotSuspendWebKitSharedTimer() {
1212   suspend_webkit_shared_timer_ = false;
1213 }
1214
1215 void RenderThreadImpl::DoNotNotifyWebKitOfModalLoop() {
1216   notify_webkit_of_modal_loop_ = false;
1217 }
1218
1219 void RenderThreadImpl::OnSetZoomLevelForCurrentURL(const std::string& scheme,
1220                                                    const std::string& host,
1221                                                    double zoom_level) {
1222   RenderViewZoomer zoomer(scheme, host, zoom_level);
1223   RenderView::ForEach(&zoomer);
1224 }
1225
1226 bool RenderThreadImpl::OnControlMessageReceived(const IPC::Message& msg) {
1227   ObserverListBase<RenderProcessObserver>::Iterator it(observers_);
1228   RenderProcessObserver* observer;
1229   while ((observer = it.GetNext()) != NULL) {
1230     if (observer->OnControlMessageReceived(msg))
1231       return true;
1232   }
1233
1234   // Some messages are handled by delegates.
1235   if (appcache_dispatcher_->OnMessageReceived(msg) ||
1236       dom_storage_dispatcher_->OnMessageReceived(msg) ||
1237       embedded_worker_dispatcher_->OnMessageReceived(msg)) {
1238     return true;
1239   }
1240
1241   bool handled = true;
1242   IPC_BEGIN_MESSAGE_MAP(RenderThreadImpl, msg)
1243     IPC_MESSAGE_HANDLER(ViewMsg_SetZoomLevelForCurrentURL,
1244                         OnSetZoomLevelForCurrentURL)
1245     // TODO(port): removed from render_messages_internal.h;
1246     // is there a new non-windows message I should add here?
1247     IPC_MESSAGE_HANDLER(ViewMsg_New, OnCreateNewView)
1248     IPC_MESSAGE_HANDLER(ViewMsg_PurgePluginListCache, OnPurgePluginListCache)
1249     IPC_MESSAGE_HANDLER(ViewMsg_NetworkStateChanged, OnNetworkStateChanged)
1250     IPC_MESSAGE_HANDLER(ViewMsg_TempCrashWithData, OnTempCrashWithData)
1251     IPC_MESSAGE_HANDLER(WorkerProcessMsg_CreateWorker, OnCreateNewSharedWorker)
1252     IPC_MESSAGE_HANDLER(ViewMsg_TimezoneChange, OnUpdateTimezone)
1253 #if defined(OS_ANDROID)
1254     IPC_MESSAGE_HANDLER(ViewMsg_SetWebKitSharedTimersSuspended,
1255                         OnSetWebKitSharedTimersSuspended)
1256 #endif
1257 #if defined(OS_MACOSX)
1258     IPC_MESSAGE_HANDLER(ViewMsg_UpdateScrollbarTheme, OnUpdateScrollbarTheme)
1259 #endif
1260     IPC_MESSAGE_UNHANDLED(handled = false)
1261   IPC_END_MESSAGE_MAP()
1262   return handled;
1263 }
1264
1265 void RenderThreadImpl::OnCreateNewView(const ViewMsg_New_Params& params) {
1266   EnsureWebKitInitialized();
1267   // When bringing in render_view, also bring in webkit's glue and jsbindings.
1268   RenderViewImpl::Create(params.opener_route_id,
1269                          params.renderer_preferences,
1270                          params.web_preferences,
1271                          params.view_id,
1272                          params.main_frame_routing_id,
1273                          params.surface_id,
1274                          params.session_storage_namespace_id,
1275                          params.frame_name,
1276                          false,
1277                          params.swapped_out,
1278                          params.hidden,
1279                          params.next_page_id,
1280                          params.screen_info,
1281                          params.accessibility_mode);
1282 }
1283
1284 GpuChannelHost* RenderThreadImpl::EstablishGpuChannelSync(
1285     CauseForGpuLaunch cause_for_gpu_launch) {
1286   TRACE_EVENT0("gpu", "RenderThreadImpl::EstablishGpuChannelSync");
1287
1288   if (gpu_channel_.get()) {
1289     // Do nothing if we already have a GPU channel or are already
1290     // establishing one.
1291     if (!gpu_channel_->IsLost())
1292       return gpu_channel_.get();
1293
1294     // Recreate the channel if it has been lost.
1295     gpu_channel_ = NULL;
1296   }
1297
1298   // Ask the browser for the channel name.
1299   int client_id = 0;
1300   IPC::ChannelHandle channel_handle;
1301   gpu::GPUInfo gpu_info;
1302   if (!Send(new GpuHostMsg_EstablishGpuChannel(cause_for_gpu_launch,
1303                                                &client_id,
1304                                                &channel_handle,
1305                                                &gpu_info)) ||
1306 #if defined(OS_POSIX)
1307       channel_handle.socket.fd == -1 ||
1308 #endif
1309       channel_handle.name.empty()) {
1310     // Otherwise cancel the connection.
1311     return NULL;
1312   }
1313
1314   GetContentClient()->SetGpuInfo(gpu_info);
1315
1316   // Cache some variables that are needed on the compositor thread for our
1317   // implementation of GpuChannelHostFactory.
1318   io_message_loop_proxy_ = ChildProcess::current()->io_message_loop_proxy();
1319
1320   gpu_channel_ = GpuChannelHost::Create(
1321       this, gpu_info, channel_handle,
1322       ChildProcess::current()->GetShutDownEvent());
1323   return gpu_channel_.get();
1324 }
1325
1326 blink::WebMediaStreamCenter* RenderThreadImpl::CreateMediaStreamCenter(
1327     blink::WebMediaStreamCenterClient* client) {
1328 #if defined(OS_ANDROID)
1329   if (CommandLine::ForCurrentProcess()->HasSwitch(
1330       switches::kDisableWebRTC))
1331     return NULL;
1332 #endif
1333
1334 #if defined(ENABLE_WEBRTC)
1335   if (!media_stream_center_) {
1336     media_stream_center_ = GetContentClient()->renderer()
1337         ->OverrideCreateWebMediaStreamCenter(client);
1338     if (!media_stream_center_) {
1339       scoped_ptr<MediaStreamCenter> media_stream_center(
1340           new MediaStreamCenter(client, GetMediaStreamDependencyFactory()));
1341       AddObserver(media_stream_center.get());
1342       media_stream_center_ = media_stream_center.release();
1343     }
1344   }
1345 #endif
1346   return media_stream_center_;
1347 }
1348
1349 MediaStreamDependencyFactory*
1350 RenderThreadImpl::GetMediaStreamDependencyFactory() {
1351   return media_stream_factory_.get();
1352 }
1353
1354 GpuChannelHost* RenderThreadImpl::GetGpuChannel() {
1355   if (!gpu_channel_.get())
1356     return NULL;
1357
1358   if (gpu_channel_->IsLost())
1359     return NULL;
1360
1361   return gpu_channel_.get();
1362 }
1363
1364 void RenderThreadImpl::OnPurgePluginListCache(bool reload_pages) {
1365   EnsureWebKitInitialized();
1366   // The call below will cause a GetPlugins call with refresh=true, but at this
1367   // point we already know that the browser has refreshed its list, so disable
1368   // refresh temporarily to prevent each renderer process causing the list to be
1369   // regenerated.
1370   webkit_platform_support_->set_plugin_refresh_allowed(false);
1371   blink::resetPluginCache(reload_pages);
1372   webkit_platform_support_->set_plugin_refresh_allowed(true);
1373
1374   FOR_EACH_OBSERVER(RenderProcessObserver, observers_, PluginListChanged());
1375 }
1376
1377 void RenderThreadImpl::OnNetworkStateChanged(bool online) {
1378   EnsureWebKitInitialized();
1379   WebNetworkStateNotifier::setOnLine(online);
1380   FOR_EACH_OBSERVER(RenderProcessObserver, observers_,
1381       NetworkStateChanged(online));
1382 }
1383
1384 void RenderThreadImpl::OnTempCrashWithData(const GURL& data) {
1385   GetContentClient()->SetActiveURL(data);
1386   CHECK(false);
1387 }
1388
1389 void RenderThreadImpl::OnUpdateTimezone() {
1390   NotifyTimezoneChange();
1391 }
1392
1393
1394 #if defined(OS_ANDROID)
1395 void RenderThreadImpl::OnSetWebKitSharedTimersSuspended(bool suspend) {
1396   if (suspend_webkit_shared_timer_) {
1397     EnsureWebKitInitialized();
1398     if (suspend) {
1399       webkit_platform_support_->SuspendSharedTimer();
1400     } else {
1401       webkit_platform_support_->ResumeSharedTimer();
1402     }
1403     webkit_shared_timer_suspended_ = suspend;
1404   }
1405 }
1406 #endif
1407
1408 #if defined(OS_MACOSX)
1409 void RenderThreadImpl::OnUpdateScrollbarTheme(
1410     float initial_button_delay,
1411     float autoscroll_button_delay,
1412     bool jump_on_track_click,
1413     blink::ScrollerStyle preferred_scroller_style,
1414     bool redraw) {
1415   EnsureWebKitInitialized();
1416   static_cast<WebScrollbarBehaviorImpl*>(
1417       webkit_platform_support_->scrollbarBehavior())->set_jump_on_track_click(
1418           jump_on_track_click);
1419   blink::WebScrollbarTheme::updateScrollbars(initial_button_delay,
1420                                              autoscroll_button_delay,
1421                                              preferred_scroller_style,
1422                                              redraw);
1423 }
1424 #endif
1425
1426 void RenderThreadImpl::OnCreateNewSharedWorker(
1427     const WorkerProcessMsg_CreateWorker_Params& params) {
1428   // EmbeddedSharedWorkerStub will self-destruct.
1429   new EmbeddedSharedWorkerStub(params.url,
1430                                params.name,
1431                                params.content_security_policy,
1432                                params.security_policy_type,
1433                                params.route_id);
1434 }
1435
1436 void RenderThreadImpl::OnMemoryPressure(
1437     base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level) {
1438   base::allocator::ReleaseFreeMemory();
1439
1440   if (memory_pressure_level ==
1441       base::MemoryPressureListener::MEMORY_PRESSURE_CRITICAL) {
1442     // Trigger full v8 garbage collection on critical memory notification.
1443     v8::V8::LowMemoryNotification();
1444     // Clear the image cache.
1445     blink::WebImageCache::clear();
1446     // Purge Skia font cache, by setting it to 0 and then again to the previous
1447     // limit.
1448     size_t font_cache_limit = SkGraphics::SetFontCacheLimit(0);
1449     SkGraphics::SetFontCacheLimit(font_cache_limit);
1450   } else {
1451     // Otherwise trigger a couple of v8 GCs using IdleNotification.
1452     if (!v8::V8::IdleNotification())
1453       v8::V8::IdleNotification();
1454   }
1455 }
1456
1457 scoped_refptr<base::MessageLoopProxy>
1458 RenderThreadImpl::GetFileThreadMessageLoopProxy() {
1459   DCHECK(message_loop() == base::MessageLoop::current());
1460   if (!file_thread_) {
1461     file_thread_.reset(new base::Thread("Renderer::FILE"));
1462     file_thread_->Start();
1463   }
1464   return file_thread_->message_loop_proxy();
1465 }
1466
1467 scoped_refptr<base::MessageLoopProxy>
1468 RenderThreadImpl::GetMediaThreadMessageLoopProxy() {
1469   DCHECK(message_loop() == base::MessageLoop::current());
1470   if (!media_thread_) {
1471     media_thread_.reset(new base::Thread("Media"));
1472     media_thread_->Start();
1473
1474 #if defined(OS_ANDROID)
1475     renderer_demuxer_ = new RendererDemuxerAndroid();
1476     AddFilter(renderer_demuxer_.get());
1477 #endif
1478   }
1479   return media_thread_->message_loop_proxy();
1480 }
1481
1482 void RenderThreadImpl::SetFlingCurveParameters(
1483     const std::vector<float>& new_touchpad,
1484     const std::vector<float>& new_touchscreen) {
1485   webkit_platform_support_->SetFlingCurveParameters(new_touchpad,
1486                                                     new_touchscreen);
1487
1488 }
1489
1490 void RenderThreadImpl::SampleGamepads(blink::WebGamepads* data) {
1491   if (!gamepad_shared_memory_reader_)
1492     gamepad_shared_memory_reader_.reset(new GamepadSharedMemoryReader);
1493   gamepad_shared_memory_reader_->SampleGamepads(*data);
1494 }
1495
1496 void RenderThreadImpl::WidgetCreated() {
1497   widget_count_++;
1498 }
1499
1500 void RenderThreadImpl::WidgetDestroyed() {
1501   widget_count_--;
1502 }
1503
1504 void RenderThreadImpl::WidgetHidden() {
1505   DCHECK_LT(hidden_widget_count_, widget_count_);
1506   hidden_widget_count_++;
1507
1508   if (widget_count_ && hidden_widget_count_ == widget_count_) {
1509 #if !defined(SYSTEM_NATIVELY_SIGNALS_MEMORY_PRESSURE)
1510     // TODO(vollick): Remove this this heavy-handed approach once we're polling
1511     // the real system memory pressure.
1512     base::MemoryPressureListener::NotifyMemoryPressure(
1513         base::MemoryPressureListener::MEMORY_PRESSURE_MODERATE);
1514 #endif
1515     if (GetContentClient()->renderer()->RunIdleHandlerWhenWidgetsHidden())
1516       ScheduleIdleHandler(kInitialIdleHandlerDelayMs);
1517   }
1518 }
1519
1520 void RenderThreadImpl::WidgetRestored() {
1521   DCHECK_GT(hidden_widget_count_, 0);
1522   hidden_widget_count_--;
1523
1524   if (!GetContentClient()->renderer()->RunIdleHandlerWhenWidgetsHidden()) {
1525     return;
1526   }
1527
1528   ScheduleIdleHandler(kLongIdleHandlerDelayMs);
1529 }
1530
1531 }  // namespace content