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