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/lazy_instance.h"
  15 #include "base/location.h"
  16 #include "base/logging.h"
  17 #include "base/memory/discardable_memory_allocator.h"
  18 #include "base/memory/shared_memory.h"
  19 #include "base/metrics/field_trial.h"
  20 #include "base/metrics/histogram.h"
  21 #include "base/path_service.h"
  22 #include "base/single_thread_task_runner.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/sys_string_conversions.h"
  27 #include "base/strings/utf_string_conversions.h"
  28 #include "base/thread_task_runner_handle.h"
  29 #include "base/threading/simple_thread.h"
  30 #include "base/threading/thread_local.h"
  31 #include "base/threading/thread_restrictions.h"
  32 #include "base/trace_event/memory_dump_manager.h"
  33 #include "base/trace_event/trace_event.h"
  34 #include "base/values.h"
  35 #include "cc/base/histograms.h"
  36 #include "cc/base/switches.h"
  37 #include "cc/blink/web_external_bitmap_impl.h"
  38 #include "cc/blink/web_layer_impl.h"
  39 #include "cc/raster/task_graph_runner.h"
  40 #include "cc/trees/layer_tree_settings.h"
  41 #include "components/scheduler/renderer/renderer_scheduler.h"
  42 #include "content/child/appcache/appcache_dispatcher.h"
  43 #include "content/child/appcache/appcache_frontend_impl.h"
  44 #include "content/child/child_discardable_shared_memory_manager.h"
  45 #include "content/child/child_gpu_memory_buffer_manager.h"
  46 #include "content/child/child_histogram_message_filter.h"
  47 #include "content/child/child_resource_message_filter.h"
  48 #include "content/child/child_shared_bitmap_manager.h"
  49 #include "content/child/content_child_helpers.h"
  50 #include "content/child/db_message_filter.h"
  51 #include "content/child/indexed_db/indexed_db_dispatcher.h"
  52 #include "content/child/indexed_db/indexed_db_message_filter.h"
  53 #include "content/child/npapi/npobject_util.h"
  54 #include "content/child/plugin_messages.h"
  55 #include "content/child/resource_dispatcher.h"
  56 #include "content/child/resource_scheduling_filter.h"
  57 #include "content/child/runtime_features.h"
  58 #include "content/child/thread_safe_sender.h"
  59 #include "content/child/web_database_observer_impl.h"
  60 #include "content/child/worker_task_runner.h"
  61 #include "content/common/child_process_messages.h"
  62 #include "content/common/content_constants_internal.h"
  63 #include "content/common/database_messages.h"
  64 #include "content/common/dom_storage/dom_storage_messages.h"
  65 #include "content/common/frame_messages.h"
  66 #include "content/common/gpu/client/context_provider_command_buffer.h"
  67 #include "content/common/gpu/client/gpu_channel_host.h"
  68 #include "content/common/gpu/gpu_messages.h"
  69 #include "content/common/gpu/gpu_process_launch_causes.h"
  70 #include "content/common/render_frame_setup.mojom.h"
  71 #include "content/common/render_process_messages.h"
  72 #include "content/common/resource_messages.h"
  73 #include "content/common/service_worker/embedded_worker_setup.mojom.h"
  74 #include "content/common/view_messages.h"
  75 #include "content/common/worker_messages.h"
  76 #include "content/public/common/content_constants.h"
  77 #include "content/public/common/content_paths.h"
  78 #include "content/public/common/content_switches.h"
  79 #include "content/public/common/mojo_channel_switches.h"
  80 #include "content/public/common/renderer_preferences.h"
  81 #include "content/public/common/url_constants.h"
  82 #include "content/public/renderer/content_renderer_client.h"
  83 #include "content/public/renderer/render_process_observer.h"
  84 #include "content/public/renderer/render_view_visitor.h"
  85 #include "content/renderer/bluetooth/bluetooth_message_filter.h"
  86 #include "content/renderer/browser_plugin/browser_plugin_manager.h"
  87 #include "content/renderer/cache_storage/cache_storage_dispatcher.h"
  88 #include "content/renderer/cache_storage/cache_storage_message_filter.h"
  89 #include "content/renderer/devtools/devtools_agent_filter.h"
  90 #include "content/renderer/devtools/v8_sampling_profiler.h"
  91 #include "content/renderer/dom_storage/dom_storage_dispatcher.h"
  92 #include "content/renderer/dom_storage/webstoragearea_impl.h"
  93 #include "content/renderer/dom_storage/webstoragenamespace_impl.h"
  94 #include "content/renderer/gpu/compositor_external_begin_frame_source.h"
  95 #include "content/renderer/gpu/compositor_forwarding_message_filter.h"
  96 #include "content/renderer/gpu/compositor_output_surface.h"
  97 #include "content/renderer/input/input_event_filter.h"
  98 #include "content/renderer/input/input_handler_manager.h"
  99 #include "content/renderer/input/main_thread_input_event_filter.h"
 100 #include "content/renderer/media/aec_dump_message_filter.h"
 101 #include "content/renderer/media/audio_input_message_filter.h"
 102 #include "content/renderer/media/audio_message_filter.h"
 103 #include "content/renderer/media/audio_renderer_mixer_manager.h"
 104 #include "content/renderer/media/media_stream_center.h"
 105 #include "content/renderer/media/midi_message_filter.h"
 106 #include "content/renderer/media/render_media_client.h"
 107 #include "content/renderer/media/renderer_gpu_video_accelerator_factories.h"
 108 #include "content/renderer/media/video_capture_impl_manager.h"
 109 #include "content/renderer/media/video_capture_message_filter.h"
 110 #include "content/renderer/net_info_helper.h"
 111 #include "content/renderer/p2p/socket_dispatcher.h"
 112 #include "content/renderer/raster_worker_pool.h"
 113 #include "content/renderer/render_frame_proxy.h"
 114 #include "content/renderer/render_process_impl.h"
 115 #include "content/renderer/render_view_impl.h"
 116 #include "content/renderer/renderer_blink_platform_impl.h"
 117 #include "content/renderer/scheduler/resource_dispatch_throttler.h"
 118 #include "content/renderer/service_worker/embedded_worker_dispatcher.h"
 119 #include "content/renderer/service_worker/service_worker_context_client.h"
 120 #include "content/renderer/service_worker/service_worker_context_message_filter.h"
 121 #include "content/renderer/shared_worker/embedded_shared_worker_stub.h"
 122 #include "gin/public/debug.h"
 123 #include "gpu/GLES2/gl2extchromium.h"
 124 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 125 #include "ipc/ipc_channel_handle.h"
 126 #include "ipc/ipc_platform_file.h"
 127 #include "ipc/mojo/ipc_channel_mojo.h"
 128 #include "media/base/audio_hardware_config.h"
 129 #include "media/base/media.h"
 130 #include "media/renderers/gpu_video_accelerator_factories.h"
 131 #include "mojo/common/common_type_converters.h"
 132 #include "net/base/net_errors.h"
 133 #include "net/base/port_util.h"
 134 #include "skia/ext/event_tracer_impl.h"
 135 #include "skia/ext/skia_memory_dump_provider.h"
 136 #include "third_party/WebKit/public/platform/WebImageGenerator.h"
 137 #include "third_party/WebKit/public/platform/WebString.h"
 138 #include "third_party/WebKit/public/platform/WebThread.h"
 139 #include "third_party/WebKit/public/web/WebCache.h"
 140 #include "third_party/WebKit/public/web/WebColorName.h"
 141 #include "third_party/WebKit/public/web/WebDatabase.h"
 142 #include "third_party/WebKit/public/web/WebDocument.h"
 143 #include "third_party/WebKit/public/web/WebFrame.h"
 144 #include "third_party/WebKit/public/web/WebImageCache.h"
 145 #include "third_party/WebKit/public/web/WebKit.h"
 146 #include "third_party/WebKit/public/web/WebNetworkStateNotifier.h"
 147 #include "third_party/WebKit/public/web/WebRuntimeFeatures.h"
 148 #include "third_party/WebKit/public/web/WebScriptController.h"
 149 #include "third_party/WebKit/public/web/WebSecurityPolicy.h"
 150 #include "third_party/WebKit/public/web/WebView.h"
 151 #include "third_party/icu/source/i18n/unicode/timezone.h"
 152 #include "third_party/mojo/src/mojo/public/cpp/bindings/strong_binding.h"
 153 #include "third_party/skia/include/core/SkGraphics.h"
 154 #include "ui/base/layout.h"
 155 #include "ui/base/ui_base_switches.h"
 156 #include "v8/include/v8.h"
 157
 158 #if defined(OS_ANDROID)
 159 #include <cpu-features.h>
 160 #include "content/renderer/android/synchronous_compositor_factory.h"
 161 #include "content/renderer/media/android/renderer_demuxer_android.h"
 162 #endif
 163
 164 #if defined(OS_MACOSX)
 165 #include "base/mac/mac_util.h"
 166 #include "content/renderer/webscrollbarbehavior_impl_mac.h"
 167 #endif
 168
 169 #if defined(OS_POSIX)
 170 #include "ipc/ipc_channel_posix.h"
 171 #endif
 172
 173 #if defined(OS_WIN)
 174 #include <windows.h>
 175 #include <objbase.h>
 176 #else
 177 // TODO(port)
 178 #include "content/child/npapi/np_channel_base.h"
 179 #endif
 180
 181 #if defined(ENABLE_PLUGINS)
 182 #include "content/renderer/npapi/plugin_channel_host.h"
 183 #endif
 184
 185 #if defined(ENABLE_WEBRTC)
 186 #include "content/renderer/media/peer_connection_tracker.h"
 187 #include "content/renderer/media/rtc_peer_connection_handler.h"
 188 #include "content/renderer/media/webrtc/peer_connection_dependency_factory.h"
 189 #include "content/renderer/media/webrtc_identity_service.h"
 190 #endif
 191
 192 #ifdef ENABLE_VTUNE_JIT_INTERFACE
 193 #include "v8/src/third_party/vtune/v8-vtune.h"
 194 #endif
 195
 196 using base::ThreadRestrictions;
 197 using blink::WebDocument;
 198 using blink::WebFrame;
 199 using blink::WebNetworkStateNotifier;
 200 using blink::WebRuntimeFeatures;
 201 using blink::WebScriptController;
 202 using blink::WebSecurityPolicy;
 203 using blink::WebString;
 204 using blink::WebView;
 205
 206 namespace content {
 207
 208 namespace {
 209
 210 const int64 kInitialIdleHandlerDelayMs = 1000;
 211 const int64 kLongIdleHandlerDelayMs = 30*1000;
 212
 213 #if defined(OS_ANDROID)
 214 // On Android, resource messages can each take ~1.5ms to dispatch on the browser
 215 // IO thread. Limiting the message rate to 3/frame at 60hz ensures that the
 216 // induced work takes but a fraction (~1/4) of the overall frame budget.
 217 const int kMaxResourceRequestsPerFlushWhenThrottled = 3;
 218 #else
 219 const int kMaxResourceRequestsPerFlushWhenThrottled = 8;
 220 #endif
 221 const double kThrottledResourceRequestFlushPeriodS = 1. / 60.;
 222
 223 // Maximum allocation size allowed for image scaling filters that
 224 // require pre-scaling. Skia will fallback to a filter that doesn't
 225 // require pre-scaling if the default filter would require an
 226 // allocation that exceeds this limit.
 227 const size_t kImageCacheSingleAllocationByteLimit = 64 * 1024 * 1024;
 228
 229 // Keep the global RenderThreadImpl in a TLS slot so it is impossible to access
 230 // incorrectly from the wrong thread.
 231 base::LazyInstance<base::ThreadLocalPointer<RenderThreadImpl> >
 232     lazy_tls = LAZY_INSTANCE_INITIALIZER;
 233
 234 class RenderViewZoomer : public RenderViewVisitor {
 235  public:
 236   RenderViewZoomer(const std::string& scheme,
 237                    const std::string& host,
 238                    double zoom_level) : scheme_(scheme),
 239                                         host_(host),
 240                                         zoom_level_(zoom_level) {
 241   }
 242
 243   bool Visit(RenderView* render_view) override {
 244     WebView* webview = render_view->GetWebView();
 245     RenderViewImpl* render_view_impl =
 246         static_cast<RenderViewImpl*>(render_view);
 247     // Remote frames don't host documents.
 248     // TODO(wjmaclean) Although it seems likely that a frame without a
 249     // document can safely early-out here, we should confirm this is truly
 250     // the case. https://crbug.com/477007
 251     if (webview->mainFrame()->isWebRemoteFrame())
 252       return true;
 253
 254     WebDocument document = webview->mainFrame()->document();
 255
 256     // Don't set zoom level for full-page plugin since they don't use the same
 257     // zoom settings.
 258     if (document.isPluginDocument())
 259       return true;
 260     GURL url(document.url());
 261     // Empty scheme works as wildcard that matches any scheme,
 262     if ((net::GetHostOrSpecFromURL(url) == host_) &&
 263         (scheme_.empty() || scheme_ == url.scheme()) &&
 264         !render_view_impl->uses_temporary_zoom_level()) {
 265       webview->hidePopups();
 266       render_view_impl->SetZoomLevel(zoom_level_);
 267     }
 268     return true;
 269   }
 270
 271  private:
 272   const std::string scheme_;
 273   const std::string host_;
 274   const double zoom_level_;
 275
 276   DISALLOW_COPY_AND_ASSIGN(RenderViewZoomer);
 277 };
 278
 279 std::string HostToCustomHistogramSuffix(const std::string& host) {
 280   if (host == "mail.google.com")
 281     return ".gmail";
 282   if (host == "docs.google.com" || host == "drive.google.com")
 283     return ".docs";
 284   if (host == "plus.google.com")
 285     return ".plus";
 286   if (host == "inbox.google.com")
 287     return ".inbox";
 288   return std::string();
 289 }
 290
 291 void* CreateHistogram(
 292     const char *name, int min, int max, size_t buckets) {
 293   if (min <= 0)
 294     min = 1;
 295   std::string histogram_name;
 296   RenderThreadImpl* render_thread_impl = RenderThreadImpl::current();
 297   if (render_thread_impl) {  // Can be null in tests.
 298     histogram_name = render_thread_impl->
 299         histogram_customizer()->ConvertToCustomHistogramName(name);
 300   } else {
 301     histogram_name = std::string(name);
 302   }
 303   base::HistogramBase* histogram = base::Histogram::FactoryGet(
 304       histogram_name, min, max, buckets,
 305       base::Histogram::kUmaTargetedHistogramFlag);
 306   return histogram;
 307 }
 308
 309 void AddHistogramSample(void* hist, int sample) {
 310   base::Histogram* histogram = static_cast<base::Histogram*>(hist);
 311   histogram->Add(sample);
 312 }
 313
 314 scoped_ptr<cc::SharedBitmap> AllocateSharedBitmapFunction(
 315     const gfx::Size& size) {
 316   return ChildThreadImpl::current()->shared_bitmap_manager()->
 317       AllocateSharedBitmap(size);
 318 }
 319
 320 void EnableBlinkPlatformLogChannels(const std::string& channels) {
 321   if (channels.empty())
 322     return;
 323   base::StringTokenizer t(channels, ", ");
 324   while (t.GetNext())
 325     blink::enableLogChannel(t.token().c_str());
 326 }
 327
 328 void NotifyTimezoneChangeOnThisThread() {
 329   v8::Isolate* isolate = v8::Isolate::GetCurrent();
 330   if (!isolate)
 331     return;
 332   v8::Date::DateTimeConfigurationChangeNotification(isolate);
 333 }
 334
 335 void LowMemoryNotificationOnThisThread() {
 336   v8::Isolate* isolate = v8::Isolate::GetCurrent();
 337   if (!isolate)
 338     return;
 339   isolate->LowMemoryNotification();
 340 }
 341
 342 class RenderFrameSetupImpl : public RenderFrameSetup {
 343  public:
 344   explicit RenderFrameSetupImpl(
 345       mojo::InterfaceRequest<RenderFrameSetup> request)
 346       : routing_id_highmark_(-1), binding_(this, request.Pass()) {}
 347
 348   void ExchangeServiceProviders(
 349       int32_t frame_routing_id,
 350       mojo::InterfaceRequest<mojo::ServiceProvider> services,
 351       mojo::ServiceProviderPtr exposed_services)
 352       override {
 353     // TODO(morrita): This is for investigating http://crbug.com/415059 and
 354     // should be removed once it is fixed.
 355     CHECK_LT(routing_id_highmark_, frame_routing_id);
 356     routing_id_highmark_ = frame_routing_id;
 357
 358     RenderFrameImpl* frame = RenderFrameImpl::FromRoutingID(frame_routing_id);
 359     // We can receive a GetServiceProviderForFrame message for a frame not yet
 360     // created due to a race between the message and a ViewMsg_New IPC that
 361     // triggers creation of the RenderFrame we want.
 362     if (!frame) {
 363       RenderThreadImpl::current()->RegisterPendingRenderFrameConnect(
 364           frame_routing_id, services.Pass(), exposed_services.Pass());
 365       return;
 366     }
 367
 368     frame->BindServiceRegistry(services.Pass(), exposed_services.Pass());
 369   }
 370
 371  private:
 372   int32_t routing_id_highmark_;
 373   mojo::StrongBinding<RenderFrameSetup> binding_;
 374 };
 375
 376 void CreateRenderFrameSetup(mojo::InterfaceRequest<RenderFrameSetup> request) {
 377   new RenderFrameSetupImpl(request.Pass());
 378 }
 379
 380 blink::WebGraphicsContext3D::Attributes GetOffscreenAttribs() {
 381   blink::WebGraphicsContext3D::Attributes attributes;
 382   attributes.shareResources = true;
 383   attributes.depth = false;
 384   attributes.stencil = false;
 385   attributes.antialias = false;
 386   attributes.noAutomaticFlushes = true;
 387   return attributes;
 388 }
 389
 390 void SetupEmbeddedWorkerOnWorkerThread(
 391     mojo::InterfaceRequest<mojo::ServiceProvider> services,
 392     mojo::ServiceProviderPtr exposed_services) {
 393   ServiceWorkerContextClient* client =
 394       ServiceWorkerContextClient::ThreadSpecificInstance();
 395   // It is possible for client to be null if for some reason the worker died
 396   // before this call made it to the worker thread. In that case just do
 397   // nothing and let mojo close the connection.
 398   if (!client)
 399     return;
 400   client->BindServiceRegistry(services.Pass(), exposed_services.Pass());
 401 }
 402
 403 class EmbeddedWorkerSetupImpl : public EmbeddedWorkerSetup {
 404  public:
 405   explicit EmbeddedWorkerSetupImpl(
 406       mojo::InterfaceRequest<EmbeddedWorkerSetup> request)
 407       : binding_(this, request.Pass()) {}
 408
 409   void ExchangeServiceProviders(
 410       int32_t thread_id,
 411       mojo::InterfaceRequest<mojo::ServiceProvider> services,
 412       mojo::ServiceProviderPtr exposed_services) override {
 413     WorkerTaskRunner::Instance()->GetTaskRunnerFor(thread_id)->PostTask(
 414         FROM_HERE,
 415         base::Bind(&SetupEmbeddedWorkerOnWorkerThread, base::Passed(&services),
 416                    base::Passed(&exposed_services)));
 417   }
 418
 419  private:
 420   mojo::StrongBinding<EmbeddedWorkerSetup> binding_;
 421 };
 422
 423 void CreateEmbeddedWorkerSetup(
 424     mojo::InterfaceRequest<EmbeddedWorkerSetup> request) {
 425   new EmbeddedWorkerSetupImpl(request.Pass());
 426 }
 427
 428 void StringToUintVector(const std::string& str, std::vector<unsigned>* vector) {
 429   DCHECK(vector->empty());
 430   std::vector<std::string> pieces = base::SplitString(
 431       str, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
 432   DCHECK_EQ(pieces.size(), static_cast<size_t>(gfx::BufferFormat::LAST) + 1);
 433   for (size_t i = 0; i < pieces.size(); ++i) {
 434     unsigned number = 0;
 435     bool succeed = base::StringToUint(pieces[i], &number);
 436     DCHECK(succeed);
 437     vector->push_back(number);
 438   }
 439 }
 440
 441 }  // namespace
 442
 443 // For measuring memory usage after each task. Behind a command line flag.
 444 class MemoryObserver : public base::MessageLoop::TaskObserver {
 445  public:
 446   MemoryObserver() {}
 447   ~MemoryObserver() override {}
 448
 449   void WillProcessTask(const base::PendingTask& pending_task) override {}
 450
 451   void DidProcessTask(const base::PendingTask& pending_task) override {
 452     LOCAL_HISTOGRAM_MEMORY_KB("Memory.RendererUsed", GetMemoryUsageKB());
 453   }
 454
 455  private:
 456   DISALLOW_COPY_AND_ASSIGN(MemoryObserver);
 457 };
 458
 459 RenderThreadImpl::HistogramCustomizer::HistogramCustomizer() {
 460   custom_histograms_.insert("V8.MemoryExternalFragmentationTotal");
 461   custom_histograms_.insert("V8.MemoryHeapSampleTotalCommitted");
 462   custom_histograms_.insert("V8.MemoryHeapSampleTotalUsed");
 463 }
 464
 465 RenderThreadImpl::HistogramCustomizer::~HistogramCustomizer() {}
 466
 467 void RenderThreadImpl::HistogramCustomizer::RenderViewNavigatedToHost(
 468     const std::string& host, size_t view_count) {
 469   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
 470           switches::kDisableHistogramCustomizer)) {
 471     return;
 472   }
 473   // Check if all RenderViews are displaying a page from the same host. If there
 474   // is only one RenderView, the common host is this view's host. If there are
 475   // many, check if this one shares the common host of the other
 476   // RenderViews. It's ok to not detect some cases where the RenderViews share a
 477   // common host. This information is only used for producing custom histograms.
 478   if (view_count == 1)
 479     SetCommonHost(host);
 480   else if (host != common_host_)
 481     SetCommonHost(std::string());
 482 }
 483
 484 std::string RenderThreadImpl::HistogramCustomizer::ConvertToCustomHistogramName(
 485     const char* histogram_name) const {
 486   std::string name(histogram_name);
 487   if (!common_host_histogram_suffix_.empty() &&
 488       custom_histograms_.find(name) != custom_histograms_.end())
 489     name += common_host_histogram_suffix_;
 490   return name;
 491 }
 492
 493 void RenderThreadImpl::HistogramCustomizer::SetCommonHost(
 494     const std::string& host) {
 495   if (host != common_host_) {
 496     common_host_ = host;
 497     common_host_histogram_suffix_ = HostToCustomHistogramSuffix(host);
 498     blink::mainThreadIsolate()->SetCreateHistogramFunction(CreateHistogram);
 499   }
 500 }
 501
 502 // static
 503 RenderThreadImpl* RenderThreadImpl::Create(
 504     const InProcessChildThreadParams& params) {
 505   scoped_ptr<scheduler::RendererScheduler> renderer_scheduler =
 506       scheduler::RendererScheduler::Create();
 507   return new RenderThreadImpl(params, renderer_scheduler.Pass());
 508 }
 509
 510 // static
 511 RenderThreadImpl* RenderThreadImpl::Create(
 512     scoped_ptr<base::MessageLoop> main_message_loop,
 513     scoped_ptr<scheduler::RendererScheduler> renderer_scheduler) {
 514   return new RenderThreadImpl(main_message_loop.Pass(),
 515                               renderer_scheduler.Pass());
 516 }
 517
 518 RenderThreadImpl* RenderThreadImpl::current() {
 519   return lazy_tls.Pointer()->Get();
 520 }
 521
 522 RenderThreadImpl::RenderThreadImpl(
 523     const InProcessChildThreadParams& params,
 524     scoped_ptr<scheduler::RendererScheduler> scheduler)
 525     : ChildThreadImpl(Options::Builder()
 526                           .InBrowserProcess(params)
 527                           .UseMojoChannel(ShouldUseMojoChannel())
 528                           .Build()),
 529       renderer_scheduler_(scheduler.Pass()),
 530       raster_worker_pool_(new RasterWorkerPool()) {
 531   Init();
 532 }
 533
 534 // When we run plugins in process, we actually run them on the render thread,
 535 // which means that we need to make the render thread pump UI events.
 536 RenderThreadImpl::RenderThreadImpl(
 537     scoped_ptr<base::MessageLoop> main_message_loop,
 538     scoped_ptr<scheduler::RendererScheduler> scheduler)
 539     : ChildThreadImpl(Options::Builder()
 540                           .UseMojoChannel(ShouldUseMojoChannel())
 541                           .Build()),
 542       renderer_scheduler_(scheduler.Pass()),
 543       main_message_loop_(main_message_loop.Pass()),
 544       raster_worker_pool_(new RasterWorkerPool()) {
 545   Init();
 546 }
 547
 548 void RenderThreadImpl::Init() {
 549   TRACE_EVENT_BEGIN_ETW("RenderThreadImpl::Init", 0, "");
 550
 551   base::trace_event::TraceLog::GetInstance()->SetThreadSortIndex(
 552       base::PlatformThread::CurrentId(),
 553       kTraceEventRendererMainThreadSortIndex);
 554
 555 #if defined(OS_MACOSX) || defined(OS_ANDROID)
 556   // On Mac and Android, the select popups are rendered by the browser.
 557   blink::WebView::setUseExternalPopupMenus(true);
 558 #endif
 559
 560   lazy_tls.Pointer()->Set(this);
 561
 562   // Register this object as the main thread.
 563   ChildProcess::current()->set_main_thread(this);
 564
 565   // In single process the single process is all there is.
 566   notify_webkit_of_modal_loop_ = true;
 567   webkit_shared_timer_suspended_ = false;
 568   widget_count_ = 0;
 569   hidden_widget_count_ = 0;
 570   idle_notification_delay_in_ms_ = kInitialIdleHandlerDelayMs;
 571   idle_notifications_to_skip_ = 0;
 572   layout_test_mode_ = false;
 573
 574   appcache_dispatcher_.reset(
 575       new AppCacheDispatcher(Get(), new AppCacheFrontendImpl()));
 576   dom_storage_dispatcher_.reset(new DomStorageDispatcher());
 577   main_thread_indexed_db_dispatcher_.reset(new IndexedDBDispatcher(
 578       thread_safe_sender()));
 579   main_thread_cache_storage_dispatcher_.reset(
 580       new CacheStorageDispatcher(thread_safe_sender()));
 581   embedded_worker_dispatcher_.reset(new EmbeddedWorkerDispatcher());
 582
 583   // Note: This may reorder messages from the ResourceDispatcher with respect to
 584   // other subsystems.
 585   resource_dispatch_throttler_.reset(new ResourceDispatchThrottler(
 586       static_cast<RenderThread*>(this), renderer_scheduler_.get(),
 587       base::TimeDelta::FromSecondsD(kThrottledResourceRequestFlushPeriodS),
 588       kMaxResourceRequestsPerFlushWhenThrottled));
 589   resource_dispatcher()->set_message_sender(resource_dispatch_throttler_.get());
 590
 591   media_stream_center_ = NULL;
 592
 593   db_message_filter_ = new DBMessageFilter();
 594   AddFilter(db_message_filter_.get());
 595
 596   vc_manager_.reset(new VideoCaptureImplManager());
 597   AddFilter(vc_manager_->video_capture_message_filter());
 598
 599   browser_plugin_manager_.reset(new BrowserPluginManager());
 600   AddObserver(browser_plugin_manager_.get());
 601
 602 #if defined(ENABLE_WEBRTC)
 603   peer_connection_tracker_.reset(new PeerConnectionTracker());
 604   AddObserver(peer_connection_tracker_.get());
 605
 606   p2p_socket_dispatcher_ =
 607       new P2PSocketDispatcher(GetIOMessageLoopProxy().get());
 608   AddFilter(p2p_socket_dispatcher_.get());
 609
 610   webrtc_identity_service_.reset(new WebRTCIdentityService());
 611
 612   aec_dump_message_filter_ = new AecDumpMessageFilter(
 613       GetIOMessageLoopProxy(), message_loop()->task_runner());
 614   AddFilter(aec_dump_message_filter_.get());
 615
 616   peer_connection_factory_.reset(new PeerConnectionDependencyFactory(
 617       p2p_socket_dispatcher_.get()));
 618 #endif  // defined(ENABLE_WEBRTC)
 619
 620   audio_input_message_filter_ =
 621       new AudioInputMessageFilter(GetIOMessageLoopProxy());
 622   AddFilter(audio_input_message_filter_.get());
 623
 624   audio_message_filter_ = new AudioMessageFilter(GetIOMessageLoopProxy());
 625   AddFilter(audio_message_filter_.get());
 626
 627   midi_message_filter_ = new MidiMessageFilter(GetIOMessageLoopProxy());
 628   AddFilter(midi_message_filter_.get());
 629
 630   bluetooth_message_filter_ = new BluetoothMessageFilter(thread_safe_sender());
 631   AddFilter(bluetooth_message_filter_->GetFilter());
 632
 633   AddFilter((new IndexedDBMessageFilter(thread_safe_sender()))->GetFilter());
 634
 635   AddFilter((new CacheStorageMessageFilter(thread_safe_sender()))->GetFilter());
 636
 637   AddFilter((new ServiceWorkerContextMessageFilter())->GetFilter());
 638
 639   GetContentClient()->renderer()->RenderThreadStarted();
 640
 641   InitSkiaEventTracer();
 642   base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
 643       skia::SkiaMemoryDumpProvider::GetInstance());
 644
 645   const base::CommandLine& command_line =
 646       *base::CommandLine::ForCurrentProcess();
 647
 648   cc::LayerSettings layer_settings;
 649   if (command_line.HasSwitch(switches::kEnableCompositorAnimationTimelines))
 650     layer_settings.use_compositor_animation_timelines = true;
 651   cc_blink::WebLayerImpl::SetLayerSettings(layer_settings);
 652   cc::SetClientNameForMetrics("Renderer");
 653
 654   is_threaded_animation_enabled_ =
 655       !command_line.HasSwitch(cc::switches::kDisableThreadedAnimation);
 656
 657   is_zero_copy_enabled_ = command_line.HasSwitch(switches::kEnableZeroCopy);
 658   is_persistent_gpu_memory_buffer_enabled_ =
 659       command_line.HasSwitch(switches::kEnablePersistentGpuMemoryBuffer);
 660
 661 #if defined(OS_MACOSX) && !defined(OS_IOS)
 662   is_elastic_overscroll_enabled_ = base::mac::IsOSLionOrLater();
 663   if (is_elastic_overscroll_enabled_) {
 664     base::ScopedCFTypeRef<CFStringRef> key(
 665         base::SysUTF8ToCFStringRef("NSScrollViewRubberbanding"));
 666     Boolean key_exists = false;
 667     Boolean value = CFPreferencesGetAppBooleanValue(
 668         key, kCFPreferencesCurrentApplication, &key_exists);
 669     if (key_exists && !value)
 670       is_elastic_overscroll_enabled_ = false;
 671   }
 672 #else
 673   is_elastic_overscroll_enabled_ = false;
 674 #endif
 675
 676   std::string image_texture_target_string =
 677       command_line.GetSwitchValueASCII(switches::kContentImageTextureTarget);
 678   StringToUintVector(image_texture_target_string, &use_image_texture_targets_);
 679
 680   if (command_line.HasSwitch(switches::kDisableLCDText)) {
 681     is_lcd_text_enabled_ = false;
 682   } else if (command_line.HasSwitch(switches::kEnableLCDText)) {
 683     is_lcd_text_enabled_ = true;
 684   } else {
 685 #if defined(OS_ANDROID)
 686     is_lcd_text_enabled_ = false;
 687 #else
 688     is_lcd_text_enabled_ = true;
 689 #endif
 690   }
 691
 692   is_gpu_rasterization_enabled_ =
 693       command_line.HasSwitch(switches::kEnableGpuRasterization);
 694   is_gpu_rasterization_forced_ =
 695       command_line.HasSwitch(switches::kForceGpuRasterization);
 696
 697   if (command_line.HasSwitch(switches::kGpuRasterizationMSAASampleCount)) {
 698     std::string string_value = command_line.GetSwitchValueASCII(
 699         switches::kGpuRasterizationMSAASampleCount);
 700     bool parsed_msaa_sample_count =
 701         base::StringToInt(string_value, &gpu_rasterization_msaa_sample_count_);
 702     DCHECK(parsed_msaa_sample_count) << string_value;
 703     DCHECK_GE(gpu_rasterization_msaa_sample_count_, 0);
 704   } else {
 705     gpu_rasterization_msaa_sample_count_ = -1;
 706   }
 707
 708   if (command_line.HasSwitch(switches::kDisableDistanceFieldText)) {
 709     is_distance_field_text_enabled_ = false;
 710   } else if (command_line.HasSwitch(switches::kEnableDistanceFieldText)) {
 711     is_distance_field_text_enabled_ = true;
 712   } else {
 713     is_distance_field_text_enabled_ = false;
 714   }
 715
 716   // Note that under Linux, the media library will normally already have
 717   // been initialized by the Zygote before this instance became a Renderer.
 718   media::InitializeMediaLibrary();
 719
 720   memory_pressure_listener_.reset(new base::MemoryPressureListener(
 721       base::Bind(&RenderThreadImpl::OnMemoryPressure, base::Unretained(this))));
 722
 723   is_gather_pixel_refs_enabled_ = false;
 724
 725   int num_raster_threads = 0;
 726   std::string string_value =
 727       command_line.GetSwitchValueASCII(switches::kNumRasterThreads);
 728   bool parsed_num_raster_threads =
 729       base::StringToInt(string_value, &num_raster_threads);
 730   DCHECK(parsed_num_raster_threads) << string_value;
 731   DCHECK_GT(num_raster_threads, 0);
 732
 733   // Note: Currently, gathering of pixel refs when using a single
 734   // raster thread doesn't provide any benefit. This might change
 735   // in the future but we avoid it for now to reduce the cost of
 736   // Picture::Create.
 737   is_gather_pixel_refs_enabled_ = num_raster_threads > 1;
 738
 739   base::SimpleThread::Options thread_options;
 740 #if defined(OS_ANDROID) || defined(OS_LINUX)
 741   if (!command_line.HasSwitch(
 742           switches::kUseNormalPriorityForTileTaskWorkerThreads)) {
 743     thread_options.set_priority(base::ThreadPriority::BACKGROUND);
 744   }
 745 #endif
 746
 747   raster_worker_pool_->Start(num_raster_threads, thread_options);
 748
 749   // TODO(boliu): In single process, browser main loop should set up the
 750   // discardable memory manager, and should skip this if kSingleProcess.
 751   // See crbug.com/503724.
 752   base::DiscardableMemoryAllocator::SetInstance(
 753       ChildThreadImpl::discardable_shared_memory_manager());
 754
 755   service_registry()->AddService<RenderFrameSetup>(
 756       base::Bind(CreateRenderFrameSetup));
 757   service_registry()->AddService<EmbeddedWorkerSetup>(
 758       base::Bind(CreateEmbeddedWorkerSetup));
 759
 760   TRACE_EVENT_END_ETW("RenderThreadImpl::Init", 0, "");
 761 }
 762
 763 RenderThreadImpl::~RenderThreadImpl() {
 764 }
 765
 766 void RenderThreadImpl::Shutdown() {
 767   FOR_EACH_OBSERVER(
 768       RenderProcessObserver, observers_, OnRenderProcessShutdown());
 769
 770   ChildThreadImpl::Shutdown();
 771
 772   if (memory_observer_) {
 773     message_loop()->RemoveTaskObserver(memory_observer_.get());
 774     memory_observer_.reset();
 775   }
 776
 777   // Wait for all databases to be closed.
 778   if (blink_platform_impl_) {
 779     // WaitForAllDatabasesToClose might run a nested message loop. To avoid
 780     // processing timer events while we're already in the process of shutting
 781     // down blink, put a ScopePageLoadDeferrer on the stack.
 782     WebView::willEnterModalLoop();
 783     blink_platform_impl_->web_database_observer_impl()
 784         ->WaitForAllDatabasesToClose();
 785     WebView::didExitModalLoop();
 786   }
 787
 788   // Shutdown in reverse of the initialization order.
 789   if (devtools_agent_message_filter_.get()) {
 790     RemoveFilter(devtools_agent_message_filter_.get());
 791     devtools_agent_message_filter_ = NULL;
 792   }
 793
 794   RemoveFilter(audio_input_message_filter_.get());
 795   audio_input_message_filter_ = NULL;
 796
 797 #if defined(ENABLE_WEBRTC)
 798   RTCPeerConnectionHandler::DestructAllHandlers();
 799   // |peer_connection_factory_| cannot be deleted until after the main message
 800   // loop has been destroyed.  This is because there may be pending tasks that
 801   // hold on to objects produced by the PC factory that depend on threads owned
 802   // by the PC factory.  Once those tasks have been freed, the factory can be
 803   // deleted.
 804 #endif
 805   RemoveFilter(vc_manager_->video_capture_message_filter());
 806   vc_manager_.reset();
 807
 808   RemoveFilter(db_message_filter_.get());
 809   db_message_filter_ = NULL;
 810
 811   // Shutdown the file thread if it's running.
 812   if (file_thread_)
 813     file_thread_->Stop();
 814
 815   if (compositor_message_filter_.get()) {
 816     RemoveFilter(compositor_message_filter_.get());
 817     compositor_message_filter_ = NULL;
 818   }
 819
 820   media_thread_.reset();
 821
 822   // AudioMessageFilter may be accessed on |media_thread_|, so shutdown after.
 823   RemoveFilter(audio_message_filter_.get());
 824   audio_message_filter_ = NULL;
 825
 826   compositor_thread_.reset();
 827
 828   raster_worker_pool_->Shutdown();
 829
 830   main_input_callback_.Cancel();
 831   input_handler_manager_.reset();
 832   if (input_event_filter_.get()) {
 833     RemoveFilter(input_event_filter_.get());
 834     input_event_filter_ = NULL;
 835   }
 836
 837   // RemoveEmbeddedWorkerRoute may be called while deleting
 838   // EmbeddedWorkerDispatcher. So it must be deleted before deleting
 839   // RenderThreadImpl.
 840   embedded_worker_dispatcher_.reset();
 841
 842   // Ramp down IDB before we ramp down WebKit (and V8), since IDB classes might
 843   // hold pointers to V8 objects (e.g., via pending requests).
 844   main_thread_indexed_db_dispatcher_.reset();
 845
 846   main_thread_compositor_task_runner_ = NULL;
 847
 848   // Context providers must be released prior to destroying the GPU channel.
 849   shared_worker_context_provider_ = nullptr;
 850   gpu_va_context_provider_ = nullptr;
 851   shared_main_thread_contexts_ = nullptr;
 852
 853   if (gpu_channel_.get())
 854     gpu_channel_->DestroyChannel();
 855
 856   // TODO(port)
 857 #if defined(OS_WIN)
 858   // Clean up plugin channels before this thread goes away.
 859   NPChannelBase::CleanupChannels();
 860 #endif
 861
 862   // Shut down the message loop and the renderer scheduler before shutting down
 863   // Blink. This prevents a scenario where a pending task in the message loop
 864   // accesses Blink objects after Blink shuts down.
 865   // This must be at the very end of the shutdown sequence. You must not touch
 866   // the message loop after this.
 867   renderer_scheduler_->Shutdown();
 868   main_message_loop_.reset();
 869   if (blink_platform_impl_) {
 870     blink_platform_impl_->Shutdown();
 871     blink::shutdown();
 872   }
 873
 874   lazy_tls.Pointer()->Set(NULL);
 875 }
 876
 877 bool RenderThreadImpl::Send(IPC::Message* msg) {
 878   // Certain synchronous messages cannot always be processed synchronously by
 879   // the browser, e.g., putting up UI and waiting for the user. This could cause
 880   // a complete hang of Chrome if a windowed plugin is trying to communicate
 881   // with the renderer thread since the browser's UI thread could be stuck
 882   // (within a Windows API call) trying to synchronously communicate with the
 883   // plugin.  The remedy is to pump messages on this thread while the browser
 884   // is processing this request. This creates an opportunity for re-entrancy
 885   // into WebKit, so we need to take care to disable callbacks, timers, and
 886   // pending network loads that could trigger such callbacks.
 887   bool pumping_events = false;
 888   if (msg->is_sync()) {
 889     if (msg->is_caller_pumping_messages()) {
 890       pumping_events = true;
 891     }
 892   }
 893
 894   bool notify_webkit_of_modal_loop = true;  // default value
 895   std::swap(notify_webkit_of_modal_loop, notify_webkit_of_modal_loop_);
 896
 897 #if defined(ENABLE_PLUGINS)
 898   int render_view_id = MSG_ROUTING_NONE;
 899 #endif
 900
 901   if (pumping_events) {
 902     renderer_scheduler_->SuspendTimerQueue();
 903
 904     if (notify_webkit_of_modal_loop)
 905       WebView::willEnterModalLoop();
 906 #if defined(ENABLE_PLUGINS)
 907     RenderViewImpl* render_view =
 908         RenderViewImpl::FromRoutingID(msg->routing_id());
 909     if (render_view) {
 910       render_view_id = msg->routing_id();
 911       PluginChannelHost::Broadcast(
 912           new PluginMsg_SignalModalDialogEvent(render_view_id));
 913     }
 914 #endif
 915   }
 916
 917   bool rv = ChildThreadImpl::Send(msg);
 918
 919   if (pumping_events) {
 920 #if defined(ENABLE_PLUGINS)
 921     if (render_view_id != MSG_ROUTING_NONE) {
 922       PluginChannelHost::Broadcast(
 923           new PluginMsg_ResetModalDialogEvent(render_view_id));
 924     }
 925 #endif
 926
 927     if (notify_webkit_of_modal_loop)
 928       WebView::didExitModalLoop();
 929
 930     renderer_scheduler_->ResumeTimerQueue();
 931   }
 932
 933   return rv;
 934 }
 935
 936 IPC::SyncChannel* RenderThreadImpl::GetChannel() {
 937   return channel();
 938 }
 939
 940 std::string RenderThreadImpl::GetLocale() {
 941   // The browser process should have passed the locale to the renderer via the
 942   // --lang command line flag.
 943   const base::CommandLine& parsed_command_line =
 944       *base::CommandLine::ForCurrentProcess();
 945   const std::string& lang =
 946       parsed_command_line.GetSwitchValueASCII(switches::kLang);
 947   DCHECK(!lang.empty());
 948   return lang;
 949 }
 950
 951 IPC::SyncMessageFilter* RenderThreadImpl::GetSyncMessageFilter() {
 952   return sync_message_filter();
 953 }
 954
 955 scoped_refptr<base::SingleThreadTaskRunner>
 956 RenderThreadImpl::GetIOMessageLoopProxy() {
 957   return ChildProcess::current()->io_task_runner();
 958 }
 959
 960 void RenderThreadImpl::AddRoute(int32 routing_id, IPC::Listener* listener) {
 961   ChildThreadImpl::GetRouter()->AddRoute(routing_id, listener);
 962   PendingRenderFrameConnectMap::iterator it =
 963       pending_render_frame_connects_.find(routing_id);
 964   if (it == pending_render_frame_connects_.end())
 965     return;
 966
 967   RenderFrameImpl* frame = RenderFrameImpl::FromRoutingID(routing_id);
 968   if (!frame)
 969     return;
 970
 971   scoped_refptr<PendingRenderFrameConnect> connection(it->second);
 972   mojo::InterfaceRequest<mojo::ServiceProvider> services(
 973       connection->services().Pass());
 974   mojo::ServiceProviderPtr exposed_services(
 975       connection->exposed_services().Pass());
 976   exposed_services.set_connection_error_handler(mojo::Closure());
 977   pending_render_frame_connects_.erase(it);
 978
 979   frame->BindServiceRegistry(services.Pass(), exposed_services.Pass());
 980 }
 981
 982 void RenderThreadImpl::RemoveRoute(int32 routing_id) {
 983   ChildThreadImpl::GetRouter()->RemoveRoute(routing_id);
 984 }
 985
 986 void RenderThreadImpl::AddEmbeddedWorkerRoute(int32 routing_id,
 987                                               IPC::Listener* listener) {
 988   AddRoute(routing_id, listener);
 989   if (devtools_agent_message_filter_.get()) {
 990     devtools_agent_message_filter_->AddEmbeddedWorkerRouteOnMainThread(
 991         routing_id);
 992   }
 993 }
 994
 995 void RenderThreadImpl::RemoveEmbeddedWorkerRoute(int32 routing_id) {
 996   RemoveRoute(routing_id);
 997   if (devtools_agent_message_filter_.get()) {
 998     devtools_agent_message_filter_->RemoveEmbeddedWorkerRouteOnMainThread(
 999         routing_id);
1000   }
1001 }
1002
1003 void RenderThreadImpl::RegisterPendingRenderFrameConnect(
1004     int routing_id,
1005     mojo::InterfaceRequest<mojo::ServiceProvider> services,
1006     mojo::ServiceProviderPtr exposed_services) {
1007   std::pair<PendingRenderFrameConnectMap::iterator, bool> result =
1008       pending_render_frame_connects_.insert(std::make_pair(
1009           routing_id,
1010           make_scoped_refptr(new PendingRenderFrameConnect(
1011               routing_id, services.Pass(), exposed_services.Pass()))));
1012   CHECK(result.second) << "Inserting a duplicate item.";
1013 }
1014
1015 int RenderThreadImpl::GenerateRoutingID() {
1016   int routing_id = MSG_ROUTING_NONE;
1017   Send(new ViewHostMsg_GenerateRoutingID(&routing_id));
1018   return routing_id;
1019 }
1020
1021 void RenderThreadImpl::AddFilter(IPC::MessageFilter* filter) {
1022   channel()->AddFilter(filter);
1023 }
1024
1025 void RenderThreadImpl::RemoveFilter(IPC::MessageFilter* filter) {
1026   channel()->RemoveFilter(filter);
1027 }
1028
1029 void RenderThreadImpl::AddObserver(RenderProcessObserver* observer) {
1030   observers_.AddObserver(observer);
1031 }
1032
1033 void RenderThreadImpl::RemoveObserver(RenderProcessObserver* observer) {
1034   observers_.RemoveObserver(observer);
1035 }
1036
1037 void RenderThreadImpl::SetResourceDispatcherDelegate(
1038     ResourceDispatcherDelegate* delegate) {
1039   resource_dispatcher()->set_delegate(delegate);
1040 }
1041
1042 void RenderThreadImpl::SetResourceDispatchTaskQueue(
1043     const scoped_refptr<base::SingleThreadTaskRunner>& resource_task_queue) {
1044   // Add a filter that forces resource messages to be dispatched via a
1045   // particular task runner.
1046   resource_scheduling_filter_ =
1047       new ResourceSchedulingFilter(resource_task_queue, resource_dispatcher());
1048   channel()->AddFilter(resource_scheduling_filter_.get());
1049
1050   // The ChildResourceMessageFilter and the ResourceDispatcher need to use the
1051   // same queue to ensure tasks are executed in the expected order.
1052   child_resource_message_filter()->SetMainThreadTaskRunner(resource_task_queue);
1053   resource_dispatcher()->SetMainThreadTaskRunner(resource_task_queue);
1054 }
1055
1056 void RenderThreadImpl::EnsureWebKitInitialized() {
1057   if (blink_platform_impl_)
1058     return;
1059
1060   const base::CommandLine& command_line =
1061       *base::CommandLine::ForCurrentProcess();
1062
1063 #ifdef ENABLE_VTUNE_JIT_INTERFACE
1064   if (command_line.HasSwitch(switches::kEnableVtune))
1065     gin::Debug::SetJitCodeEventHandler(vTune::GetVtuneCodeEventHandler());
1066 #endif
1067
1068   SetRuntimeFeaturesDefaultsAndUpdateFromArgs(command_line);
1069
1070   blink_platform_impl_.reset(
1071       new RendererBlinkPlatformImpl(renderer_scheduler_.get()));
1072   blink::initialize(blink_platform_impl_.get());
1073
1074   v8::Isolate* isolate = blink::mainThreadIsolate();
1075   isolate->SetCreateHistogramFunction(CreateHistogram);
1076   isolate->SetAddHistogramSampleFunction(AddHistogramSample);
1077
1078   main_thread_compositor_task_runner_ =
1079       renderer_scheduler_->CompositorTaskRunner();
1080
1081   main_input_callback_.Reset(
1082       base::Bind(base::IgnoreResult(&RenderThreadImpl::OnMessageReceived),
1083                  base::Unretained(this)));
1084
1085   SetResourceDispatchTaskQueue(renderer_scheduler_->LoadingTaskRunner());
1086
1087   bool enable = !command_line.HasSwitch(switches::kDisableThreadedCompositing);
1088   if (enable) {
1089 #if defined(OS_ANDROID)
1090     if (SynchronousCompositorFactory* factory =
1091         SynchronousCompositorFactory::GetInstance())
1092       compositor_task_runner_ = factory->GetCompositorTaskRunner();
1093 #endif
1094     if (!compositor_task_runner_.get()) {
1095       compositor_thread_.reset(new base::Thread("Compositor"));
1096       base::Thread::Options compositor_thread_options;
1097 #if defined(OS_ANDROID)
1098       compositor_thread_options.priority = base::ThreadPriority::DISPLAY;
1099 #endif
1100       compositor_thread_->StartWithOptions(compositor_thread_options);
1101       compositor_task_runner_ = compositor_thread_->task_runner();
1102       compositor_task_runner_->PostTask(
1103           FROM_HERE,
1104           base::Bind(base::IgnoreResult(&ThreadRestrictions::SetIOAllowed),
1105                      false));
1106     }
1107
1108     InputHandlerManagerClient* input_handler_manager_client = NULL;
1109 #if defined(OS_ANDROID)
1110     if (SynchronousCompositorFactory* factory =
1111         SynchronousCompositorFactory::GetInstance()) {
1112       input_handler_manager_client = factory->GetInputHandlerManagerClient();
1113     }
1114 #endif
1115     if (!input_handler_manager_client) {
1116       scoped_refptr<InputEventFilter> compositor_input_event_filter(
1117           new InputEventFilter(main_input_callback_.callback(),
1118                                main_thread_compositor_task_runner_,
1119                                compositor_task_runner_));
1120       input_handler_manager_client = compositor_input_event_filter.get();
1121       input_event_filter_ = compositor_input_event_filter;
1122     }
1123     input_handler_manager_.reset(new InputHandlerManager(
1124         compositor_task_runner_, input_handler_manager_client,
1125         renderer_scheduler_.get()));
1126   }
1127
1128   if (!input_event_filter_.get()) {
1129     // Always provide an input event filter implementation to ensure consistent
1130     // input event scheduling and prioritization.
1131     // TODO(jdduke): Merge InputEventFilter, InputHandlerManager and
1132     // MainThreadInputEventFilter, crbug.com/436057.
1133     input_event_filter_ = new MainThreadInputEventFilter(
1134         main_input_callback_.callback(), main_thread_compositor_task_runner_);
1135   }
1136   AddFilter(input_event_filter_.get());
1137
1138   scoped_refptr<base::SingleThreadTaskRunner> compositor_impl_side_task_runner;
1139   if (enable)
1140     compositor_impl_side_task_runner = compositor_task_runner_;
1141   else
1142     compositor_impl_side_task_runner = base::ThreadTaskRunnerHandle::Get();
1143
1144   compositor_message_filter_ = new CompositorForwardingMessageFilter(
1145       compositor_impl_side_task_runner.get());
1146   AddFilter(compositor_message_filter_.get());
1147
1148   RenderThreadImpl::RegisterSchemes();
1149
1150   EnableBlinkPlatformLogChannels(
1151       command_line.GetSwitchValueASCII(switches::kBlinkPlatformLogChannels));
1152
1153   RenderMediaClient::Initialize();
1154
1155   FOR_EACH_OBSERVER(RenderProcessObserver, observers_, WebKitInitialized());
1156
1157   devtools_agent_message_filter_ = new DevToolsAgentFilter();
1158   AddFilter(devtools_agent_message_filter_.get());
1159
1160   v8_sampling_profiler_.reset(new V8SamplingProfiler());
1161
1162   if (GetContentClient()->renderer()->RunIdleHandlerWhenWidgetsHidden())
1163     ScheduleIdleHandler(kLongIdleHandlerDelayMs);
1164
1165   renderer_scheduler_->SetTimerQueueSuspensionWhenBackgroundedEnabled(
1166       GetContentClient()
1167           ->renderer()
1168           ->AllowTimerSuspensionWhenProcessBackgrounded());
1169
1170   cc_blink::SetSharedBitmapAllocationFunction(AllocateSharedBitmapFunction);
1171
1172   SkGraphics::SetResourceCacheSingleAllocationByteLimit(
1173       kImageCacheSingleAllocationByteLimit);
1174
1175   // Hook up blink's codecs so skia can call them
1176   SkGraphics::SetImageGeneratorFromEncodedFactory(
1177       blink::WebImageGenerator::create);
1178
1179   if (command_line.HasSwitch(switches::kMemoryMetrics)) {
1180     memory_observer_.reset(new MemoryObserver());
1181     message_loop()->AddTaskObserver(memory_observer_.get());
1182   }
1183
1184   if (command_line.HasSwitch(switches::kExplicitlyAllowedPorts)) {
1185     std::string allowed_ports =
1186         command_line.GetSwitchValueASCII(switches::kExplicitlyAllowedPorts);
1187     net::SetExplicitlyAllowedPorts(allowed_ports);
1188   }
1189 }
1190
1191 void RenderThreadImpl::RegisterSchemes() {
1192   // swappedout:
1193   WebString swappedout_scheme(base::ASCIIToUTF16(kSwappedOutScheme));
1194   WebSecurityPolicy::registerURLSchemeAsDisplayIsolated(swappedout_scheme);
1195   WebSecurityPolicy::registerURLSchemeAsEmptyDocument(swappedout_scheme);
1196
1197   // chrome:
1198   WebString chrome_scheme(base::ASCIIToUTF16(kChromeUIScheme));
1199   WebSecurityPolicy::registerURLSchemeAsDisplayIsolated(chrome_scheme);
1200   WebSecurityPolicy::registerURLSchemeAsNotAllowingJavascriptURLs(
1201       chrome_scheme);
1202   WebSecurityPolicy::registerURLSchemeAsSecure(chrome_scheme);
1203   WebSecurityPolicy::registerURLSchemeAsCORSEnabled(chrome_scheme);
1204
1205   // chrome-devtools:
1206   WebString devtools_scheme(base::ASCIIToUTF16(kChromeDevToolsScheme));
1207   WebSecurityPolicy::registerURLSchemeAsDisplayIsolated(devtools_scheme);
1208 }
1209
1210 void RenderThreadImpl::NotifyTimezoneChange() {
1211   NotifyTimezoneChangeOnThisThread();
1212   RenderThread::Get()->PostTaskToAllWebWorkers(
1213       base::Bind(&NotifyTimezoneChangeOnThisThread));
1214 }
1215
1216 void RenderThreadImpl::RecordAction(const base::UserMetricsAction& action) {
1217   Send(new ViewHostMsg_UserMetricsRecordAction(action.str_));
1218 }
1219
1220 void RenderThreadImpl::RecordComputedAction(const std::string& action) {
1221   Send(new ViewHostMsg_UserMetricsRecordAction(action));
1222 }
1223
1224 scoped_ptr<base::SharedMemory>
1225     RenderThreadImpl::HostAllocateSharedMemoryBuffer(size_t size) {
1226   return ChildThreadImpl::AllocateSharedMemory(size, thread_safe_sender());
1227 }
1228
1229 cc::SharedBitmapManager* RenderThreadImpl::GetSharedBitmapManager() {
1230   return shared_bitmap_manager();
1231 }
1232
1233 void RenderThreadImpl::RegisterExtension(v8::Extension* extension) {
1234   EnsureWebKitInitialized();
1235   WebScriptController::registerExtension(extension);
1236 }
1237
1238 void RenderThreadImpl::ScheduleIdleHandler(int64 initial_delay_ms) {
1239   idle_notification_delay_in_ms_ = initial_delay_ms;
1240   idle_timer_.Stop();
1241   idle_timer_.Start(FROM_HERE,
1242       base::TimeDelta::FromMilliseconds(initial_delay_ms),
1243       this, &RenderThreadImpl::IdleHandler);
1244 }
1245
1246 void RenderThreadImpl::IdleHandler() {
1247   bool run_in_foreground_tab = (widget_count_ > hidden_widget_count_) &&
1248                                GetContentClient()->renderer()->
1249                                    RunIdleHandlerWhenWidgetsHidden();
1250   if (run_in_foreground_tab) {
1251     if (idle_notifications_to_skip_ > 0) {
1252       --idle_notifications_to_skip_;
1253     } else {
1254       ReleaseFreeMemory();
1255     }
1256     ScheduleIdleHandler(kLongIdleHandlerDelayMs);
1257     return;
1258   }
1259
1260   ReleaseFreeMemory();
1261
1262   // Continue the idle timer if the webkit shared timer is not suspended or
1263   // something is left to do.
1264   bool continue_timer = !webkit_shared_timer_suspended_;
1265
1266   if (blink::mainThreadIsolate() &&
1267       !blink::mainThreadIsolate()->IdleNotificationDeadline(
1268           blink_platform_impl_->monotonicallyIncreasingTime() + 1.0)) {
1269     continue_timer = true;
1270   }
1271
1272   // Schedule next invocation. When the tab is originally hidden, an invocation
1273   // is scheduled for kInitialIdleHandlerDelayMs in
1274   // RenderThreadImpl::WidgetHidden in order to race to a minimal heap.
1275   // After that, idle calls can be much less frequent, so run at a maximum of
1276   // once every kLongIdleHandlerDelayMs.
1277   // Dampen the delay using the algorithm (if delay is in seconds):
1278   //    delay = delay + 1 / (delay + 2)
1279   // Using floor(delay) has a dampening effect such as:
1280   //    30s, 30, 30, 31, 31, 31, 31, 32, 32, ...
1281   // If the delay is in milliseconds, the above formula is equivalent to:
1282   //    delay_ms / 1000 = delay_ms / 1000 + 1 / (delay_ms / 1000 + 2)
1283   // which is equivalent to
1284   //    delay_ms = delay_ms + 1000*1000 / (delay_ms + 2000).
1285   if (continue_timer) {
1286     ScheduleIdleHandler(
1287         std::max(kLongIdleHandlerDelayMs,
1288                  idle_notification_delay_in_ms_ +
1289                  1000000 / (idle_notification_delay_in_ms_ + 2000)));
1290
1291   } else {
1292     idle_timer_.Stop();
1293   }
1294
1295   FOR_EACH_OBSERVER(RenderProcessObserver, observers_, IdleNotification());
1296 }
1297
1298 int64 RenderThreadImpl::GetIdleNotificationDelayInMs() const {
1299   return idle_notification_delay_in_ms_;
1300 }
1301
1302 void RenderThreadImpl::SetIdleNotificationDelayInMs(
1303     int64 idle_notification_delay_in_ms) {
1304   idle_notification_delay_in_ms_ = idle_notification_delay_in_ms;
1305 }
1306
1307 void RenderThreadImpl::UpdateHistograms(int sequence_number) {
1308   child_histogram_message_filter()->SendHistograms(sequence_number);
1309 }
1310
1311 int RenderThreadImpl::PostTaskToAllWebWorkers(const base::Closure& closure) {
1312   return WorkerTaskRunner::Instance()->PostTaskToAllThreads(closure);
1313 }
1314
1315 bool RenderThreadImpl::ResolveProxy(const GURL& url, std::string* proxy_list) {
1316   bool result = false;
1317   Send(new ViewHostMsg_ResolveProxy(url, &result, proxy_list));
1318   return result;
1319 }
1320
1321 void RenderThreadImpl::PostponeIdleNotification() {
1322   idle_notifications_to_skip_ = 2;
1323 }
1324
1325 scoped_refptr<media::GpuVideoAcceleratorFactories>
1326 RenderThreadImpl::GetGpuFactories() {
1327   DCHECK(IsMainThread());
1328
1329   const base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
1330
1331 #if defined(OS_ANDROID)
1332   if (SynchronousCompositorFactory::GetInstance()) {
1333     if (!cmd_line->HasSwitch(switches::kDisableAcceleratedVideoDecode)) {
1334       DLOG(WARNING) << "Accelerated video decoding is not explicitly disabled, "
1335                        "but is not supported by in-process rendering";
1336     }
1337     return NULL;
1338   }
1339 #endif
1340
1341   scoped_refptr<GpuChannelHost> gpu_channel_host = GetGpuChannel();
1342   scoped_refptr<media::GpuVideoAcceleratorFactories> gpu_factories;
1343   scoped_refptr<base::SingleThreadTaskRunner> media_task_runner =
1344       GetMediaThreadTaskRunner();
1345   if (gpu_va_context_provider_.get() && !gpu_channel_host.get()) {
1346     // The GPU channel was lost. It's possible that |gpu_va_context_provider_|
1347     // has not been made aware of that, so always create a new one.
1348     gpu_va_context_provider_ = nullptr;
1349   }
1350   if (!gpu_va_context_provider_.get() ||
1351       gpu_va_context_provider_->DestroyedOnMainThread()) {
1352     if (!gpu_channel_host.get()) {
1353       gpu_channel_host = EstablishGpuChannelSync(
1354           CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE);
1355     }
1356     blink::WebGraphicsContext3D::Attributes attributes;
1357     bool lose_context_when_out_of_memory = false;
1358     gpu_va_context_provider_ = ContextProviderCommandBuffer::Create(
1359         make_scoped_ptr(
1360             WebGraphicsContext3DCommandBufferImpl::CreateOffscreenContext(
1361                 gpu_channel_host.get(), attributes,
1362                 lose_context_when_out_of_memory,
1363                 GURL("chrome://gpu/RenderThreadImpl::GetGpuVDAContext3D"),
1364                 WebGraphicsContext3DCommandBufferImpl::SharedMemoryLimits(),
1365                 NULL)),
1366         GPU_VIDEO_ACCELERATOR_CONTEXT);
1367   }
1368   if (gpu_va_context_provider_.get()) {
1369     const bool enable_video_accelerator =
1370         !cmd_line->HasSwitch(switches::kDisableAcceleratedVideoDecode);
1371     const bool enable_gpu_memory_buffer_video_frames =
1372 #if defined(OS_MACOSX)
1373         !cmd_line->HasSwitch(switches::kDisableGpuMemoryBufferVideoFrames);
1374 #else
1375         cmd_line->HasSwitch(switches::kEnableGpuMemoryBufferVideoFrames);
1376 #endif
1377     std::string image_texture_target_string =
1378         cmd_line->GetSwitchValueASCII(switches::kVideoImageTextureTarget);
1379     unsigned image_texture_target = 0;
1380     const bool parsed_image_texture_target =
1381         base::StringToUint(image_texture_target_string, &image_texture_target);
1382     DCHECK(parsed_image_texture_target);
1383     gpu_factories = RendererGpuVideoAcceleratorFactories::Create(
1384         gpu_channel_host.get(), media_task_runner, gpu_va_context_provider_,
1385         enable_gpu_memory_buffer_video_frames, image_texture_target,
1386         enable_video_accelerator);
1387   }
1388   return gpu_factories;
1389 }
1390
1391 scoped_ptr<WebGraphicsContext3DCommandBufferImpl>
1392 RenderThreadImpl::CreateOffscreenContext3d() {
1393   blink::WebGraphicsContext3D::Attributes attributes(GetOffscreenAttribs());
1394   bool lose_context_when_out_of_memory = true;
1395
1396   scoped_refptr<GpuChannelHost> gpu_channel_host(EstablishGpuChannelSync(
1397       CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE));
1398   return make_scoped_ptr(
1399       WebGraphicsContext3DCommandBufferImpl::CreateOffscreenContext(
1400           gpu_channel_host.get(),
1401           attributes,
1402           lose_context_when_out_of_memory,
1403           GURL("chrome://gpu/RenderThreadImpl::CreateOffscreenContext3d"),
1404           WebGraphicsContext3DCommandBufferImpl::SharedMemoryLimits(),
1405           NULL));
1406 }
1407
1408 scoped_refptr<cc_blink::ContextProviderWebContext>
1409 RenderThreadImpl::SharedMainThreadContextProvider() {
1410   DCHECK(IsMainThread());
1411   if (!shared_main_thread_contexts_.get() ||
1412       shared_main_thread_contexts_->DestroyedOnMainThread()) {
1413     shared_main_thread_contexts_ = NULL;
1414 #if defined(OS_ANDROID)
1415     SynchronousCompositorFactory* factory =
1416         SynchronousCompositorFactory::GetInstance();
1417     if (factory && factory->OverrideWithFactory()) {
1418       shared_main_thread_contexts_ = factory->CreateOffscreenContextProvider(
1419           GetOffscreenAttribs(), "Offscreen-MainThread");
1420     }
1421 #endif
1422     if (!shared_main_thread_contexts_.get()) {
1423       shared_main_thread_contexts_ = ContextProviderCommandBuffer::Create(
1424           CreateOffscreenContext3d(), RENDERER_MAINTHREAD_CONTEXT);
1425     }
1426     if (shared_main_thread_contexts_.get() &&
1427         !shared_main_thread_contexts_->BindToCurrentThread())
1428       shared_main_thread_contexts_ = NULL;
1429   }
1430   return shared_main_thread_contexts_;
1431 }
1432
1433 AudioRendererMixerManager* RenderThreadImpl::GetAudioRendererMixerManager() {
1434   if (!audio_renderer_mixer_manager_) {
1435     audio_renderer_mixer_manager_.reset(new AudioRendererMixerManager(
1436         GetAudioHardwareConfig()));
1437   }
1438
1439   return audio_renderer_mixer_manager_.get();
1440 }
1441
1442 media::AudioHardwareConfig* RenderThreadImpl::GetAudioHardwareConfig() {
1443   if (!audio_hardware_config_) {
1444     media::AudioParameters input_params;
1445     media::AudioParameters output_params;
1446     Send(new ViewHostMsg_GetAudioHardwareConfig(
1447         &input_params, &output_params));
1448
1449     audio_hardware_config_.reset(new media::AudioHardwareConfig(
1450         input_params, output_params));
1451   }
1452
1453   return audio_hardware_config_.get();
1454 }
1455
1456 base::WaitableEvent* RenderThreadImpl::GetShutdownEvent() {
1457   return ChildProcess::current()->GetShutDownEvent();
1458 }
1459
1460 #if defined(OS_WIN)
1461 void RenderThreadImpl::PreCacheFontCharacters(const LOGFONT& log_font,
1462                                               const base::string16& str) {
1463   Send(new RenderProcessHostMsg_PreCacheFontCharacters(log_font, str));
1464 }
1465
1466 #endif  // OS_WIN
1467
1468 ServiceRegistry* RenderThreadImpl::GetServiceRegistry() {
1469   return service_registry();
1470 }
1471
1472 bool RenderThreadImpl::IsGpuRasterizationForced() {
1473   return is_gpu_rasterization_forced_;
1474 }
1475
1476 bool RenderThreadImpl::IsGpuRasterizationEnabled() {
1477   return is_gpu_rasterization_enabled_;
1478 }
1479
1480 int RenderThreadImpl::GetGpuRasterizationMSAASampleCount() {
1481   return gpu_rasterization_msaa_sample_count_;
1482 }
1483
1484 bool RenderThreadImpl::IsLcdTextEnabled() {
1485   return is_lcd_text_enabled_;
1486 }
1487
1488 bool RenderThreadImpl::IsDistanceFieldTextEnabled() {
1489   return is_distance_field_text_enabled_;
1490 }
1491
1492 bool RenderThreadImpl::IsZeroCopyEnabled() {
1493   return is_zero_copy_enabled_;
1494 }
1495
1496 bool RenderThreadImpl::IsPersistentGpuMemoryBufferEnabled() {
1497   return is_persistent_gpu_memory_buffer_enabled_;
1498 }
1499
1500 bool RenderThreadImpl::IsElasticOverscrollEnabled() {
1501   return is_elastic_overscroll_enabled_;
1502 }
1503
1504 std::vector<unsigned> RenderThreadImpl::GetImageTextureTargets() {
1505   return use_image_texture_targets_;
1506 }
1507
1508 scoped_refptr<base::SingleThreadTaskRunner>
1509 RenderThreadImpl::GetCompositorMainThreadTaskRunner() {
1510   return main_thread_compositor_task_runner_;
1511 }
1512
1513 scoped_refptr<base::SingleThreadTaskRunner>
1514 RenderThreadImpl::GetCompositorImplThreadTaskRunner() {
1515   return compositor_task_runner_;
1516 }
1517
1518 gpu::GpuMemoryBufferManager* RenderThreadImpl::GetGpuMemoryBufferManager() {
1519   return gpu_memory_buffer_manager();
1520 }
1521
1522 scheduler::RendererScheduler* RenderThreadImpl::GetRendererScheduler() {
1523   return renderer_scheduler_.get();
1524 }
1525
1526 cc::ContextProvider* RenderThreadImpl::GetSharedMainThreadContextProvider() {
1527   return SharedMainThreadContextProvider().get();
1528 }
1529
1530 scoped_ptr<cc::BeginFrameSource>
1531 RenderThreadImpl::CreateExternalBeginFrameSource(int routing_id) {
1532 #if defined(OS_ANDROID)
1533   if (SynchronousCompositorFactory* factory =
1534           SynchronousCompositorFactory::GetInstance()) {
1535     return factory->CreateExternalBeginFrameSource(routing_id);
1536   }
1537 #endif
1538   return make_scoped_ptr(new CompositorExternalBeginFrameSource(
1539       compositor_message_filter_.get(), sync_message_filter(), routing_id));
1540 }
1541
1542 cc::TaskGraphRunner* RenderThreadImpl::GetTaskGraphRunner() {
1543   return raster_worker_pool_->GetTaskGraphRunner();
1544 }
1545
1546 bool RenderThreadImpl::IsGatherPixelRefsEnabled() {
1547   return is_gather_pixel_refs_enabled_;
1548 }
1549
1550 bool RenderThreadImpl::IsThreadedAnimationEnabled() {
1551   return is_threaded_animation_enabled_;
1552 }
1553
1554 bool RenderThreadImpl::IsMainThread() {
1555   return !!current();
1556 }
1557
1558 scoped_refptr<base::SingleThreadTaskRunner>
1559 RenderThreadImpl::GetIOThreadTaskRunner() {
1560   return io_thread_task_runner_;
1561 }
1562
1563 scoped_ptr<base::SharedMemory> RenderThreadImpl::AllocateSharedMemory(
1564     size_t size) {
1565   return scoped_ptr<base::SharedMemory>(
1566       HostAllocateSharedMemoryBuffer(size));
1567 }
1568
1569 CreateCommandBufferResult RenderThreadImpl::CreateViewCommandBuffer(
1570       int32 surface_id,
1571       const GPUCreateCommandBufferConfig& init_params,
1572       int32 route_id) {
1573   TRACE_EVENT1("gpu",
1574                "RenderThreadImpl::CreateViewCommandBuffer",
1575                "surface_id",
1576                surface_id);
1577
1578   CreateCommandBufferResult result = CREATE_COMMAND_BUFFER_FAILED;
1579   IPC::Message* message = new GpuHostMsg_CreateViewCommandBuffer(
1580       surface_id,
1581       init_params,
1582       route_id,
1583       &result);
1584
1585   // Allow calling this from the compositor thread.
1586   thread_safe_sender()->Send(message);
1587
1588   return result;
1589 }
1590
1591 void RenderThreadImpl::DoNotNotifyWebKitOfModalLoop() {
1592   notify_webkit_of_modal_loop_ = false;
1593 }
1594
1595 bool RenderThreadImpl::OnControlMessageReceived(const IPC::Message& msg) {
1596   base::ObserverListBase<RenderProcessObserver>::Iterator it(&observers_);
1597   RenderProcessObserver* observer;
1598   while ((observer = it.GetNext()) != NULL) {
1599     if (observer->OnControlMessageReceived(msg))
1600       return true;
1601   }
1602
1603   // Some messages are handled by delegates.
1604   if (appcache_dispatcher_->OnMessageReceived(msg) ||
1605       dom_storage_dispatcher_->OnMessageReceived(msg) ||
1606       embedded_worker_dispatcher_->OnMessageReceived(msg)) {
1607     return true;
1608   }
1609
1610   bool handled = true;
1611   IPC_BEGIN_MESSAGE_MAP(RenderThreadImpl, msg)
1612     IPC_MESSAGE_HANDLER(FrameMsg_NewFrame, OnCreateNewFrame)
1613     IPC_MESSAGE_HANDLER(FrameMsg_NewFrameProxy, OnCreateNewFrameProxy)
1614     IPC_MESSAGE_HANDLER(ViewMsg_SetZoomLevelForCurrentURL,
1615                         OnSetZoomLevelForCurrentURL)
1616     // TODO(port): removed from render_messages_internal.h;
1617     // is there a new non-windows message I should add here?
1618     IPC_MESSAGE_HANDLER(ViewMsg_New, OnCreateNewView)
1619     IPC_MESSAGE_HANDLER(ViewMsg_NetworkTypeChanged, OnNetworkTypeChanged)
1620     IPC_MESSAGE_HANDLER(WorkerProcessMsg_CreateWorker, OnCreateNewSharedWorker)
1621     IPC_MESSAGE_HANDLER(ViewMsg_TimezoneChange, OnUpdateTimezone)
1622 #if defined(OS_ANDROID)
1623     IPC_MESSAGE_HANDLER(ViewMsg_SetWebKitSharedTimersSuspended,
1624                         OnSetWebKitSharedTimersSuspended)
1625 #endif
1626 #if defined(OS_MACOSX)
1627     IPC_MESSAGE_HANDLER(ViewMsg_UpdateScrollbarTheme, OnUpdateScrollbarTheme)
1628 #endif
1629 #if defined(ENABLE_PLUGINS)
1630     IPC_MESSAGE_HANDLER(ViewMsg_PurgePluginListCache, OnPurgePluginListCache)
1631 #endif
1632     IPC_MESSAGE_UNHANDLED(handled = false)
1633   IPC_END_MESSAGE_MAP()
1634   return handled;
1635 }
1636
1637 void RenderThreadImpl::OnProcessBackgrounded(bool backgrounded) {
1638   ChildThreadImpl::OnProcessBackgrounded(backgrounded);
1639
1640   if (backgrounded)
1641     renderer_scheduler_->OnRendererBackgrounded();
1642   else
1643     renderer_scheduler_->OnRendererForegrounded();
1644 }
1645
1646 void RenderThreadImpl::OnCreateNewFrame(FrameMsg_NewFrame_Params params) {
1647   CompositorDependencies* compositor_deps = this;
1648   RenderFrameImpl::CreateFrame(
1649       params.routing_id, params.proxy_routing_id, params.opener_routing_id,
1650       params.parent_routing_id, params.previous_sibling_routing_id,
1651       params.replication_state, compositor_deps, params.widget_params);
1652 }
1653
1654 void RenderThreadImpl::OnCreateNewFrameProxy(
1655     int routing_id,
1656     int render_view_routing_id,
1657     int opener_routing_id,
1658     int parent_routing_id,
1659     const FrameReplicationState& replicated_state) {
1660   RenderFrameProxy::CreateFrameProxy(routing_id, render_view_routing_id,
1661                                      opener_routing_id, parent_routing_id,
1662                                      replicated_state);
1663 }
1664
1665 void RenderThreadImpl::OnSetZoomLevelForCurrentURL(const std::string& scheme,
1666                                                    const std::string& host,
1667                                                    double zoom_level) {
1668   RenderViewZoomer zoomer(scheme, host, zoom_level);
1669   RenderView::ForEach(&zoomer);
1670 }
1671
1672 void RenderThreadImpl::OnCreateNewView(const ViewMsg_New_Params& params) {
1673   EnsureWebKitInitialized();
1674   CompositorDependencies* compositor_deps = this;
1675   // When bringing in render_view, also bring in webkit's glue and jsbindings.
1676   RenderViewImpl::Create(compositor_deps, params, false);
1677 }
1678
1679 GpuChannelHost* RenderThreadImpl::EstablishGpuChannelSync(
1680     CauseForGpuLaunch cause_for_gpu_launch) {
1681   TRACE_EVENT0("gpu", "RenderThreadImpl::EstablishGpuChannelSync");
1682
1683   if (gpu_channel_.get()) {
1684     // Do nothing if we already have a GPU channel or are already
1685     // establishing one.
1686     if (!gpu_channel_->IsLost())
1687       return gpu_channel_.get();
1688
1689     // Recreate the channel if it has been lost.
1690     gpu_channel_->DestroyChannel();
1691     gpu_channel_ = NULL;
1692   }
1693
1694   // Ask the browser for the channel name.
1695   int client_id = 0;
1696   IPC::ChannelHandle channel_handle;
1697   gpu::GPUInfo gpu_info;
1698   if (!Send(new GpuHostMsg_EstablishGpuChannel(cause_for_gpu_launch,
1699                                                &client_id,
1700                                                &channel_handle,
1701                                                &gpu_info)) ||
1702 #if defined(OS_POSIX)
1703       channel_handle.socket.fd == -1 ||
1704 #endif
1705       channel_handle.name.empty()) {
1706     // Otherwise cancel the connection.
1707     return NULL;
1708   }
1709
1710   GetContentClient()->SetGpuInfo(gpu_info);
1711
1712   // Cache some variables that are needed on the compositor thread for our
1713   // implementation of GpuChannelHostFactory.
1714   io_thread_task_runner_ = ChildProcess::current()->io_task_runner();
1715
1716   gpu_channel_ =
1717       GpuChannelHost::Create(this,
1718                              client_id,
1719                              gpu_info,
1720                              channel_handle,
1721                              ChildProcess::current()->GetShutDownEvent(),
1722                              gpu_memory_buffer_manager());
1723   return gpu_channel_.get();
1724 }
1725
1726 blink::WebMediaStreamCenter* RenderThreadImpl::CreateMediaStreamCenter(
1727     blink::WebMediaStreamCenterClient* client) {
1728 #if defined(ENABLE_WEBRTC)
1729   if (!media_stream_center_) {
1730     media_stream_center_ = GetContentClient()->renderer()
1731         ->OverrideCreateWebMediaStreamCenter(client);
1732     if (!media_stream_center_) {
1733       scoped_ptr<MediaStreamCenter> media_stream_center(
1734           new MediaStreamCenter(client, GetPeerConnectionDependencyFactory()));
1735       media_stream_center_ = media_stream_center.release();
1736     }
1737   }
1738 #endif
1739   return media_stream_center_;
1740 }
1741
1742 #if defined(ENABLE_WEBRTC)
1743 PeerConnectionDependencyFactory*
1744 RenderThreadImpl::GetPeerConnectionDependencyFactory() {
1745   return peer_connection_factory_.get();
1746 }
1747 #endif
1748
1749 GpuChannelHost* RenderThreadImpl::GetGpuChannel() {
1750   if (!gpu_channel_.get())
1751     return NULL;
1752
1753   if (gpu_channel_->IsLost())
1754     return NULL;
1755
1756   return gpu_channel_.get();
1757 }
1758
1759 #if defined(ENABLE_PLUGINS)
1760 void RenderThreadImpl::OnPurgePluginListCache(bool reload_pages) {
1761   EnsureWebKitInitialized();
1762   // The call below will cause a GetPlugins call with refresh=true, but at this
1763   // point we already know that the browser has refreshed its list, so disable
1764   // refresh temporarily to prevent each renderer process causing the list to be
1765   // regenerated.
1766   blink_platform_impl_->set_plugin_refresh_allowed(false);
1767   blink::resetPluginCache(reload_pages);
1768   blink_platform_impl_->set_plugin_refresh_allowed(true);
1769
1770   FOR_EACH_OBSERVER(RenderProcessObserver, observers_, PluginListChanged());
1771 }
1772 #endif
1773
1774 void RenderThreadImpl::OnNetworkTypeChanged(
1775     net::NetworkChangeNotifier::ConnectionType type) {
1776   EnsureWebKitInitialized();
1777   bool online = type != net::NetworkChangeNotifier::CONNECTION_NONE;
1778   WebNetworkStateNotifier::setOnLine(online);
1779   FOR_EACH_OBSERVER(
1780       RenderProcessObserver, observers_, NetworkStateChanged(online));
1781   WebNetworkStateNotifier::setWebConnectionType(
1782       NetConnectionTypeToWebConnectionType(type));
1783 }
1784
1785 void RenderThreadImpl::OnUpdateTimezone(const std::string& zone_id) {
1786   if (!blink_platform_impl_)
1787     return;
1788   if (!zone_id.empty()) {
1789     icu::TimeZone *new_zone = icu::TimeZone::createTimeZone(
1790         icu::UnicodeString::fromUTF8(zone_id));
1791     icu::TimeZone::adoptDefault(new_zone);
1792     VLOG(1) << "ICU default timezone is set to " << zone_id;
1793   }
1794   NotifyTimezoneChange();
1795 }
1796
1797 #if defined(OS_ANDROID)
1798 void RenderThreadImpl::OnSetWebKitSharedTimersSuspended(bool suspend) {
1799   EnsureWebKitInitialized();
1800   if (suspend) {
1801     renderer_scheduler_->SuspendTimerQueue();
1802   } else {
1803     renderer_scheduler_->ResumeTimerQueue();
1804   }
1805   webkit_shared_timer_suspended_ = suspend;
1806 }
1807 #endif
1808
1809 #if defined(OS_MACOSX)
1810 void RenderThreadImpl::OnUpdateScrollbarTheme(
1811     const ViewMsg_UpdateScrollbarTheme_Params& params) {
1812   EnsureWebKitInitialized();
1813   static_cast<WebScrollbarBehaviorImpl*>(
1814       blink_platform_impl_->scrollbarBehavior())
1815       ->set_jump_on_track_click(params.jump_on_track_click);
1816
1817   blink::WebScrollbarTheme::updateScrollbarsWithNSDefaults(
1818       params.initial_button_delay, params.autoscroll_button_delay,
1819       params.preferred_scroller_style, params.redraw,
1820       params.scroll_animation_enabled, params.button_placement);
1821 }
1822 #endif
1823
1824 void RenderThreadImpl::OnCreateNewSharedWorker(
1825     const WorkerProcessMsg_CreateWorker_Params& params) {
1826   // EmbeddedSharedWorkerStub will self-destruct.
1827   new EmbeddedSharedWorkerStub(params.url,
1828                                params.name,
1829                                params.content_security_policy,
1830                                params.security_policy_type,
1831                                params.pause_on_start,
1832                                params.route_id);
1833 }
1834
1835 void RenderThreadImpl::OnMemoryPressure(
1836     base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level) {
1837   ReleaseFreeMemory();
1838
1839   // Do not call into blink if it is not initialized.
1840   if (blink_platform_impl_) {
1841     blink::WebCache::pruneAll();
1842
1843     if (blink::mainThreadIsolate()) {
1844       // Trigger full v8 garbage collection on memory pressure notifications.
1845       // This will potentially hang the renderer for a long time, however, when
1846       // we receive a memory pressure notification, we might be about to be
1847       // killed.
1848       blink::mainThreadIsolate()->LowMemoryNotification();
1849       RenderThread::Get()->PostTaskToAllWebWorkers(
1850           base::Bind(&LowMemoryNotificationOnThisThread));
1851     }
1852
1853     if (memory_pressure_level ==
1854         base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL) {
1855       // Clear the image cache.
1856       blink::WebImageCache::clear();
1857
1858       // Purge Skia font cache, by setting it to 0 and then again to the
1859       // previous limit.
1860       size_t font_cache_limit = SkGraphics::SetFontCacheLimit(0);
1861       SkGraphics::SetFontCacheLimit(font_cache_limit);
1862     }
1863   }
1864 }
1865
1866 scoped_refptr<base::SingleThreadTaskRunner>
1867 RenderThreadImpl::GetFileThreadMessageLoopProxy() {
1868   DCHECK(message_loop() == base::MessageLoop::current());
1869   if (!file_thread_) {
1870     file_thread_.reset(new base::Thread("Renderer::FILE"));
1871     file_thread_->Start();
1872   }
1873   return file_thread_->task_runner();
1874 }
1875
1876 scoped_refptr<base::SingleThreadTaskRunner>
1877 RenderThreadImpl::GetMediaThreadTaskRunner() {
1878   DCHECK(message_loop() == base::MessageLoop::current());
1879   if (!media_thread_) {
1880     media_thread_.reset(new base::Thread("Media"));
1881     media_thread_->Start();
1882
1883 #if defined(OS_ANDROID)
1884     renderer_demuxer_ = new RendererDemuxerAndroid();
1885     AddFilter(renderer_demuxer_.get());
1886 #endif
1887   }
1888   return media_thread_->task_runner();
1889 }
1890
1891 base::TaskRunner* RenderThreadImpl::GetWorkerTaskRunner() {
1892   return raster_worker_pool_.get();
1893 }
1894
1895 scoped_refptr<ContextProviderCommandBuffer>
1896 RenderThreadImpl::SharedWorkerContextProvider() {
1897   DCHECK(IsMainThread());
1898   // Try to reuse existing shared worker context provider.
1899   bool shared_worker_context_provider_lost = false;
1900   if (shared_worker_context_provider_) {
1901     // Note: If context is lost, delete reference after releasing the lock.
1902     base::AutoLock lock(*shared_worker_context_provider_->GetLock());
1903     if (shared_worker_context_provider_->ContextGL()
1904             ->GetGraphicsResetStatusKHR() != GL_NO_ERROR) {
1905       shared_worker_context_provider_lost = true;
1906     }
1907   }
1908   if (!shared_worker_context_provider_ || shared_worker_context_provider_lost) {
1909     shared_worker_context_provider_ = ContextProviderCommandBuffer::Create(
1910         CreateOffscreenContext3d(), RENDER_WORKER_CONTEXT);
1911     if (shared_worker_context_provider_ &&
1912         !shared_worker_context_provider_->BindToCurrentThread())
1913       shared_worker_context_provider_ = nullptr;
1914     if (shared_worker_context_provider_)
1915       shared_worker_context_provider_->SetupLock();
1916   }
1917   return shared_worker_context_provider_;
1918 }
1919
1920 void RenderThreadImpl::SampleGamepads(blink::WebGamepads* data) {
1921   blink_platform_impl_->sampleGamepads(*data);
1922 }
1923
1924 bool RenderThreadImpl::RendererIsHidden() const {
1925   return widget_count_ > 0 && hidden_widget_count_ == widget_count_;
1926 }
1927
1928 void RenderThreadImpl::WidgetCreated() {
1929   bool renderer_was_hidden = RendererIsHidden();
1930   widget_count_++;
1931   if (renderer_was_hidden)
1932     OnRendererVisible();
1933 }
1934
1935 void RenderThreadImpl::WidgetDestroyed() {
1936   // TODO(rmcilroy): Remove the restriction that destroyed widgets must be
1937   // unhidden before WidgetDestroyed is called.
1938   DCHECK_GT(widget_count_, 0);
1939   DCHECK_GT(widget_count_, hidden_widget_count_);
1940   widget_count_--;
1941   if (RendererIsHidden())
1942     OnRendererHidden();
1943 }
1944
1945 void RenderThreadImpl::WidgetHidden() {
1946   DCHECK_LT(hidden_widget_count_, widget_count_);
1947   hidden_widget_count_++;
1948   if (RendererIsHidden())
1949     OnRendererHidden();
1950 }
1951
1952 void RenderThreadImpl::WidgetRestored() {
1953   bool renderer_was_hidden = RendererIsHidden();
1954   DCHECK_GT(hidden_widget_count_, 0);
1955   hidden_widget_count_--;
1956   if (renderer_was_hidden)
1957     OnRendererVisible();
1958 }
1959
1960 void RenderThreadImpl::OnRendererHidden() {
1961   renderer_scheduler_->OnRendererHidden();
1962
1963   // TODO(rmcilroy): Remove IdleHandler and replace it with an IdleTask
1964   // scheduled by the RendererScheduler - http://crbug.com/469210.
1965   if (GetContentClient()->renderer()->RunIdleHandlerWhenWidgetsHidden())
1966     ScheduleIdleHandler(kInitialIdleHandlerDelayMs);
1967 }
1968
1969 void RenderThreadImpl::OnRendererVisible() {
1970   renderer_scheduler_->OnRendererVisible();
1971
1972   if (!GetContentClient()->renderer()->RunIdleHandlerWhenWidgetsHidden())
1973     return;
1974
1975   ScheduleIdleHandler(kLongIdleHandlerDelayMs);
1976 }
1977
1978 void RenderThreadImpl::ReleaseFreeMemory() {
1979   base::allocator::ReleaseFreeMemory();
1980   discardable_shared_memory_manager()->ReleaseFreeMemory();
1981
1982   if (blink_platform_impl_)
1983     blink::decommitFreeableMemory();
1984 }
1985
1986 RenderThreadImpl::PendingRenderFrameConnect::PendingRenderFrameConnect(
1987     int routing_id,
1988     mojo::InterfaceRequest<mojo::ServiceProvider> services,
1989     mojo::ServiceProviderPtr exposed_services)
1990     : routing_id_(routing_id),
1991       services_(services.Pass()),
1992       exposed_services_(exposed_services.Pass()) {
1993   // The RenderFrame may be deleted before the ExchangeServiceProviders message
1994   // is received. In that case, the RenderFrameHost should close the connection,
1995   // which is detected by setting an error handler on |exposed_services_|.
1996   exposed_services_.set_connection_error_handler(base::Bind(
1997       &RenderThreadImpl::PendingRenderFrameConnect::OnConnectionError,
1998       base::Unretained(this)));
1999 }
2000
2001 RenderThreadImpl::PendingRenderFrameConnect::~PendingRenderFrameConnect() {
2002 }
2003
2004 void RenderThreadImpl::PendingRenderFrameConnect::OnConnectionError() {
2005   size_t erased =
2006       RenderThreadImpl::current()->pending_render_frame_connects_.erase(
2007           routing_id_);
2008   DCHECK_EQ(1u, erased);
2009 }
2010
2011 }  // namespace content