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