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