blob: 71958217741768f66065be62ad5d742b70effdb6 [file] [log] [blame]
[email protected]d3d6325d2012-01-03 21:17:361// Copyright (c) 2012 The Chromium Authors. All rights reserved.
license.botbf09a502008-08-24 00:55:552// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
initial.commit09911bf2008-07-26 23:55:294
[email protected]f1a29a02011-10-06 23:08:445#ifndef CONTENT_RENDERER_RENDER_THREAD_IMPL_H_
6#define CONTENT_RENDERER_RENDER_THREAD_IMPL_H_
initial.commit09911bf2008-07-26 23:55:297
avi1023d012015-12-25 02:39:148#include <stddef.h>
9#include <stdint.h>
10
maxmorin017ba8c62017-06-02 10:23:0911#include <map>
leon.han21e0e482017-02-23 04:13:3212#include <memory>
[email protected]6779aa12011-03-29 17:32:2413#include <set>
[email protected]b68d5ed2009-04-16 02:41:2814#include <string>
maxmorin017ba8c62017-06-02 10:23:0915#include <utility>
[email protected]1bc83062009-02-06 00:16:3716#include <vector>
17
jdduke691dd572014-12-02 20:47:5218#include "base/cancelable_callback.h"
avi1023d012015-12-25 02:39:1419#include "base/macros.h"
hajimehoshi7bb39582016-10-12 04:30:5720#include "base/memory/memory_coordinator_client.h"
[email protected]5071cb22013-07-10 02:19:0621#include "base/memory/memory_pressure_listener.h"
rockot775ce0d2015-01-27 18:35:0122#include "base/memory/ref_counted.h"
[email protected]e6e30ac2014-01-13 21:24:3923#include "base/metrics/user_metrics_action.h"
[email protected]1223d6ef2011-03-28 16:47:5024#include "base/observer_list.h"
maxmorin017ba8c62017-06-02 10:23:0925#include "base/optional.h"
[email protected]21aa99682013-06-11 07:17:0126#include "base/strings/string16.h"
[email protected]88105162013-12-05 01:02:1227#include "base/threading/thread_checker.h"
tbansal99d8aeb2017-05-22 19:12:5828#include "base/time/time.h"
[email protected]abb522162013-06-28 01:54:1629#include "base/timer/timer.h"
[email protected]037fce02009-01-22 01:42:1530#include "build/build_config.h"
jam8a021512a2015-02-03 18:16:0831#include "content/child/child_thread_impl.h"
bashia6264042016-09-15 04:49:5132#include "content/child/memory/child_memory_coordinator_impl.h"
rockot067ca55f2016-09-30 22:00:1533#include "content/common/associated_interface_registry_impl.h"
[email protected]8d128d62011-09-13 22:11:5734#include "content/common/content_export.h"
ben76f52b242016-06-18 05:42:4835#include "content/common/frame.mojom.h"
alexmosbc7eafa2014-12-06 01:38:0936#include "content/common/frame_replication_state.h"
samans2040988b2017-04-11 23:58:3537#include "content/common/frame_sink_provider.mojom.h"
rockot1587e332016-07-27 17:44:1438#include "content/common/render_frame_message_filter.mojom.h"
rockote261d2112016-09-21 22:22:2339#include "content/common/render_message_filter.mojom.h"
rockot067ca55f2016-09-30 22:00:1540#include "content/common/renderer.mojom.h"
jam188f19f2017-06-07 03:56:2441#include "content/common/renderer_host.mojom.h"
jamc912ca32016-02-24 20:17:3142#include "content/common/storage_partition_service.mojom.h"
mmenke680c2142017-07-05 19:08:5643#include "content/public/common/url_loader_factory.mojom.h"
[email protected]526476902011-10-06 20:34:0644#include "content/public/renderer/render_thread.h"
Yuzhu Shenfe5f3a52018-01-11 21:24:1345#include "content/public/renderer/url_loader_throttle_provider.h"
danakj6e3bf8012014-12-16 18:27:5346#include "content/renderer/gpu/compositor_dependencies.h"
danakj83066a32016-06-21 02:34:4947#include "content/renderer/layout_test_dependencies.h"
maxmorin017ba8c62017-06-02 10:23:0948#include "content/renderer/media/audio_ipc_factory.h"
penghuang346a46f92016-03-31 21:37:5249#include "gpu/ipc/client/gpu_channel_host.h"
Antoine Laboure55c9ef82017-11-10 18:51:2350#include "ipc/ipc_sync_channel.h"
Brett Wilson0748bf412016-11-22 17:55:4651#include "media/media_features.h"
rockot067ca55f2016-09-30 22:00:1552#include "mojo/public/cpp/bindings/associated_binding.h"
blundellc00adf442016-09-16 10:43:4153#include "mojo/public/cpp/bindings/binding.h"
jcivelli315d17f2016-11-29 16:15:0554#include "mojo/public/cpp/bindings/thread_safe_interface_ptr.h"
[email protected]d7ff5fb2014-05-29 19:50:2555#include "net/base/network_change_notifier.h"
tbansalb612c5d2017-05-25 18:53:0656#include "net/nqe/effective_connection_type.h"
Ben Goodger21ada1e2017-07-19 14:53:0157#include "services/service_manager/public/cpp/bind_source_info.h"
Ken Rockot510c5972017-12-05 16:37:0458#include "services/service_manager/public/cpp/binder_registry.h"
danakjab9ef4d2017-10-31 23:38:3359#include "services/viz/public/interfaces/compositing/compositing_mode_watcher.mojom.h"
[email protected]d7ff5fb2014-05-29 19:50:2560#include "third_party/WebKit/public/platform/WebConnectionType.h"
skyostil529caa292016-08-10 17:44:5161#include "third_party/WebKit/public/platform/scheduler/renderer/renderer_scheduler.h"
tasakb46626a2016-10-18 05:54:4462#include "third_party/WebKit/public/web/WebMemoryStatistics.h"
[email protected]08397d52011-02-05 01:53:3863#include "ui/gfx/native_widget_types.h"
initial.commit09911bf2008-07-26 23:55:2964
[email protected]291857a2014-01-23 17:49:1165#if defined(OS_MACOSX)
Joel Hockey473bc632017-06-16 02:17:2466#include "third_party/WebKit/public/platform/mac/WebScrollbarTheme.h"
[email protected]291857a2014-01-23 17:49:1167#endif
68
[email protected]39008c02009-02-11 23:59:2569class SkBitmap;
[email protected]46f36a492010-07-28 19:36:4170
[email protected]180ef242013-11-07 06:50:4671namespace blink {
skyostil529caa292016-08-10 17:44:5172namespace scheduler {
73class WebThreadBase;
74}
[email protected]d8cd8372012-03-09 10:49:5175class WebMediaStreamCenter;
76class WebMediaStreamCenterClient;
[email protected]b7c7bcf2009-10-03 07:07:3477}
78
[email protected]64ffa0442011-10-03 22:08:3679namespace base {
skyostil457b0a12014-09-09 10:12:0780class SingleThreadTaskRunner;
[email protected]64ffa0442011-10-03 22:08:3681class Thread;
82}
83
[email protected]c29b7ff2013-03-06 03:51:0484namespace cc {
jbrianceed975022016-11-04 09:14:2585class BeginFrameSource;
danakjc7afae52017-06-20 21:12:4186class LayerTreeFrameSink;
samans09812d32017-03-27 19:51:5087class SyntheticBeginFrameSource;
reveman34b7a1522015-03-23 20:27:4788class TaskGraphRunner;
[email protected]c29b7ff2013-03-06 03:51:0489}
90
juncai2f298a82017-04-18 03:51:3991namespace device {
92class Gamepads;
93}
94
penghuang342762b2016-12-02 21:04:5895namespace discardable_memory {
96class ClientDiscardableSharedMemoryManager;
97}
98
penghuang346a46f92016-03-31 21:37:5299namespace gpu {
100class GpuChannelHost;
101}
102
[email protected]1842fe22012-08-13 23:24:35103namespace IPC {
[email protected]74122042014-04-25 00:07:30104class MessageFilter;
[email protected]1842fe22012-08-13 23:24:35105}
106
[email protected]563d665f2013-02-01 04:42:39107namespace media {
[email protected]2329bfc72014-02-28 02:03:21108class GpuVideoAcceleratorFactories;
[email protected]563d665f2013-02-01 04:42:39109}
110
sadrul9e0bb1d2016-08-04 20:18:39111namespace ui {
sadrul85cc5d82016-12-20 03:37:41112class ContextProviderCommandBuffer;
sadrul04cfa892016-12-09 17:53:49113class Gpu;
sadrul9e0bb1d2016-08-04 20:18:39114}
115
[email protected]e9ff79c2012-10-19 21:31:26116namespace v8 {
117class Extension;
118}
119
danakj92429852017-06-29 00:19:03120namespace viz {
Fady Samuelc645ffe2017-07-24 17:28:20121class BeginFrameSource;
danakj92429852017-06-29 00:19:03122class ClientSharedBitmapManager;
Victor Miuraff6488612017-12-21 04:16:15123class RasterContextProvider;
Fady Samuelc645ffe2017-07-24 17:28:20124class SyntheticBeginFrameSource;
danakj92429852017-06-29 00:19:03125}
126
[email protected]64ffa0442011-10-03 22:08:36127namespace content {
[email protected]e9ff79c2012-10-19 21:31:26128
[email protected]eb398192012-10-22 20:16:19129class AppCacheDispatcher;
[email protected]da9f30a2014-06-18 19:39:04130class AecDumpMessageFilter;
[email protected]9a292e22012-10-22 15:19:31131class AudioInputMessageFilter;
132class AudioMessageFilter;
[email protected]3958e972012-07-17 00:25:41133class AudioRendererMixerManager;
dmurph1fb98482016-03-30 21:14:26134class BlobMessageFilter;
fsamuel6c1dfeb2014-12-18 19:21:33135class BrowserPluginManager;
jsbell279efb42015-03-31 17:02:46136class CacheStorageDispatcher;
John Abd-El-Maleke1d4de32017-10-21 16:14:29137class CategorizedWorkerPool;
simonhonga7e3ac42014-11-11 20:50:22138class CompositorForwardingMessageFilter;
[email protected]e9ff79c2012-10-19 21:31:26139class DomStorageDispatcher;
John Abd-El-Malekdcf1d1372017-10-22 06:39:41140class FileSystemDispatcher;
danakj83066a32016-06-21 02:34:49141class FrameSwapMessageQueue;
John Abd-El-Maleke1d4de32017-10-21 16:14:29142class GpuVideoAcceleratorFactoriesImpl;
[email protected]eb398192012-10-22 20:16:19143class IndexedDBDispatcher;
[email protected]ea5f70a2013-03-07 12:30:36144class InputHandlerManager;
[email protected]6e068ea2014-02-04 07:05:47145class MidiMessageFilter;
John Abd-El-Malekf9f86c12017-10-21 07:22:23146class NotificationDispatcher;
[email protected]4761cf12012-09-12 10:37:55147class P2PSocketDispatcher;
jsbellabadb9b2015-03-23 21:03:44148class PeerConnectionDependencyFactory;
[email protected]af089972013-01-10 04:04:40149class PeerConnectionTracker;
John Abd-El-Malekf75a3192017-10-22 14:23:20150class QuotaDispatcher;
tyoshino832a58a2016-04-18 08:14:08151class RenderThreadObserver;
tfarina556a7232014-10-05 01:02:09152class RendererBlinkPlatformImpl;
John Abd-El-Malek6b56ef712017-10-21 22:52:46153class ResourceDispatcher;
John Abd-El-Maleke1d4de32017-10-21 16:14:29154class ServiceWorkerMessageFilter;
[email protected]9a292e22012-10-22 15:19:31155class VideoCaptureImplManager;
[email protected]cb25aa12012-08-07 19:13:43156
boliubee541f42015-11-05 00:52:53157#if defined(OS_ANDROID)
siva.gunturi5d4feb052015-11-15 16:15:31158class StreamTextureFactory;
boliubee541f42015-11-05 00:52:53159class SynchronousCompositorFilter;
160#endif
161
jam8a021512a2015-02-03 18:16:08162#if defined(COMPILER_MSVC)
163// See explanation for other RenderViewHostImpl which is the same issue.
164#pragma warning(push)
165#pragma warning(disable: 4250)
166#endif
167
[email protected]f1a29a02011-10-06 23:08:44168// The RenderThreadImpl class represents a background thread where RenderView
initial.commit09911bf2008-07-26 23:55:29169// instances live. The RenderThread supports an API that is used by its
170// consumer to talk indirectly to the RenderViews and supporting objects.
171// Likewise, it provides an API for the RenderViews to talk back to the main
[email protected]770005b2012-04-16 15:58:13172// process (i.e., their corresponding WebContentsImpl).
initial.commit09911bf2008-07-26 23:55:29173//
174// Most of the communication occurs in the form of IPC messages. They are
175// routed to the RenderThread according to the routing IDs of the messages.
176// The routing IDs correspond to RenderView instances.
danakj6e3bf8012014-12-16 18:27:53177class CONTENT_EXPORT RenderThreadImpl
178 : public RenderThread,
jam8a021512a2015-02-03 18:16:08179 public ChildThreadImpl,
skyostil529caa292016-08-10 17:44:51180 public blink::scheduler::RendererScheduler::RAILModeObserver,
bashia6264042016-09-15 04:49:51181 public ChildMemoryCoordinatorDelegate,
hajimehoshi7bb39582016-10-12 04:30:57182 public base::MemoryCoordinatorClient,
Nico Weber43ddd7a32017-08-15 19:19:27183 public mojom::Renderer,
danakjab9ef4d2017-10-31 23:38:33184 public viz::mojom::CompositingModeWatcher,
Nico Weber43ddd7a32017-08-15 19:19:27185 public CompositorDependencies {
initial.commit09911bf2008-07-26 23:55:29186 public:
leon.han2c0f9f12015-07-11 02:01:19187 static RenderThreadImpl* Create(const InProcessChildThreadParams& params);
188 static RenderThreadImpl* Create(
dchengcedca5612016-04-09 01:40:15189 std::unique_ptr<base::MessageLoop> main_message_loop,
skyostil529caa292016-08-10 17:44:51190 std::unique_ptr<blink::scheduler::RendererScheduler> renderer_scheduler);
[email protected]f1a29a02011-10-06 23:08:44191 static RenderThreadImpl* current();
rockot5c478a72016-09-28 23:14:18192 static mojom::RenderMessageFilter* current_render_message_filter();
olegmax045f7fb12017-05-19 07:58:55193 static RendererBlinkPlatformImpl* current_blink_platform_impl();
rockot5c478a72016-09-28 23:14:18194
195 static void SetRenderMessageFilterForTesting(
196 mojom::RenderMessageFilter* render_message_filter);
olegmax045f7fb12017-05-19 07:58:55197 static void SetRendererBlinkPlatformImplForTesting(
198 RendererBlinkPlatformImpl* blink_platform_impl);
[email protected]526476902011-10-06 20:34:06199
John Abd-El-Malekd4882642017-12-04 21:45:19200 // Returns the task runner for the main thread where the RenderThread lives.
201 static scoped_refptr<base::SingleThreadTaskRunner> GetMainTaskRunner();
202
dcheng6d18e402014-10-21 12:32:52203 ~RenderThreadImpl() override;
204 void Shutdown() override;
harakenbbfdd9f02017-01-12 07:14:04205 bool ShouldBeDestroyed() override;
initial.commit09911bf2008-07-26 23:55:29206
[email protected]58436a12012-03-21 17:10:26207 // When initializing WebKit, ensure that any schemes needed for the content
208 // module are registered properly. Static to allow sharing with tests.
209 static void RegisterSchemes();
210
[email protected]e9ff79c2012-10-19 21:31:26211 // RenderThread implementation:
dcheng6d18e402014-10-21 12:32:52212 bool Send(IPC::Message* msg) override;
dcheng6d18e402014-10-21 12:32:52213 IPC::SyncChannel* GetChannel() override;
214 std::string GetLocale() override;
215 IPC::SyncMessageFilter* GetSyncMessageFilter() override;
avi1023d012015-12-25 02:39:14216 void AddRoute(int32_t routing_id, IPC::Listener* listener) override;
217 void RemoveRoute(int32_t routing_id) override;
dcheng6d18e402014-10-21 12:32:52218 int GenerateRoutingID() override;
219 void AddFilter(IPC::MessageFilter* filter) override;
220 void RemoveFilter(IPC::MessageFilter* filter) override;
tyoshino832a58a2016-04-18 08:14:08221 void AddObserver(RenderThreadObserver* observer) override;
222 void RemoveObserver(RenderThreadObserver* observer) override;
dcheng6d18e402014-10-21 12:32:52223 void SetResourceDispatcherDelegate(
mohan.reddyee0b42a2014-10-08 04:53:14224 ResourceDispatcherDelegate* delegate) override;
dchengcedca5612016-04-09 01:40:15225 std::unique_ptr<base::SharedMemory> HostAllocateSharedMemoryBuffer(
mohan.reddyee0b42a2014-10-08 04:53:14226 size_t buffer_size) override;
Fady Samuel4b5f9862017-07-11 05:27:20227 viz::SharedBitmapManager* GetSharedBitmapManager() override;
dcheng6d18e402014-10-21 12:32:52228 void RegisterExtension(v8::Extension* extension) override;
avi1023d012015-12-25 02:39:14229 void ScheduleIdleHandler(int64_t initial_delay_ms) override;
dcheng6d18e402014-10-21 12:32:52230 void IdleHandler() override;
avi1023d012015-12-25 02:39:14231 int64_t GetIdleNotificationDelayInMs() const override;
dcheng6d18e402014-10-21 12:32:52232 void SetIdleNotificationDelayInMs(
avi1023d012015-12-25 02:39:14233 int64_t idle_notification_delay_in_ms) override;
dcheng6d18e402014-10-21 12:32:52234 int PostTaskToAllWebWorkers(const base::Closure& closure) override;
235 bool ResolveProxy(const GURL& url, std::string* proxy_list) override;
236 base::WaitableEvent* GetShutdownEvent() override;
staraz067f58242016-11-07 21:06:41237 int32_t GetClientId() override;
Karan Bhatiac89897f2017-08-10 01:06:40238 void SetRendererProcessType(
239 blink::scheduler::RendererProcessType type) override;
[email protected]1223d6ef2011-03-28 16:47:50240
rockot067ca55f2016-09-30 22:00:15241 // IPC::Listener implementation via ChildThreadImpl:
John Abd-El-Malek6b56ef712017-10-21 22:52:46242 bool OnMessageReceived(const IPC::Message& msg) override;
rockot067ca55f2016-09-30 22:00:15243 void OnAssociatedInterfaceRequest(
244 const std::string& name,
245 mojo::ScopedInterfaceEndpointHandle handle) override;
246
weilifabbf7572017-05-22 19:05:16247 // ChildThread implementation via ChildThreadImpl:
248 scoped_refptr<base::SingleThreadTaskRunner> GetIOTaskRunner() override;
249
danakj6e3bf8012014-12-16 18:27:53250 // CompositorDependencies implementation.
danakj6e3bf8012014-12-16 18:27:53251 bool IsGpuRasterizationForced() override;
senorblancob60ba952015-01-27 19:12:36252 int GetGpuRasterizationMSAASampleCount() override;
danakj6e3bf8012014-12-16 18:27:53253 bool IsLcdTextEnabled() override;
254 bool IsDistanceFieldTextEnabled() override;
255 bool IsZeroCopyEnabled() override;
ericrk1d17f752015-10-20 03:03:07256 bool IsPartialRasterEnabled() override;
ccameronc7fcd132015-11-03 20:14:31257 bool IsGpuMemoryBufferCompositorResourcesEnabled() override;
ccamerona7644752014-12-30 01:16:31258 bool IsElasticOverscrollEnabled() override;
danakj6e3bf8012014-12-16 18:27:53259 scoped_refptr<base::SingleThreadTaskRunner>
260 GetCompositorMainThreadTaskRunner() override;
261 scoped_refptr<base::SingleThreadTaskRunner>
262 GetCompositorImplThreadTaskRunner() override;
skyostil529caa292016-08-10 17:44:51263 blink::scheduler::RendererScheduler* GetRendererScheduler() override;
reveman34b7a1522015-03-23 20:27:47264 cc::TaskGraphRunner* GetTaskGraphRunner() override;
loyso65c93c602015-08-11 05:15:57265 bool IsThreadedAnimationEnabled() override;
wjmaclean1d970622017-01-21 22:28:24266 bool IsScrollAnimatorEnabled() override;
Khushal3e96e662017-10-30 23:16:50267 std::unique_ptr<cc::UkmRecorderFactory> CreateUkmRecorderFactory() override;
danakj6e3bf8012014-12-16 18:27:53268
skyostil529caa292016-08-10 17:44:51269 // blink::scheduler::RendererScheduler::RAILModeObserver implementation.
skyostila37c2a72016-06-29 17:30:07270 void OnRAILModeChanged(v8::RAILMode rail_mode) override;
271
danakjab9ef4d2017-10-31 23:38:33272 // viz::mojom::CompositingModeWatcher implementation.
273 void CompositingModeFallbackToSoftware() override;
274
275 // Whether gpu compositing is being used or is disabled for software
276 // compositing. Clients of the compositor should give resources that match
277 // the appropriate mode.
278 bool IsGpuCompositingDisabled() { return is_gpu_compositing_disabled_; }
279
[email protected]b3e83de2012-02-07 03:33:28280 // Synchronously establish a channel to the GPU plugin if not previously
281 // established or if it has been lost (for example if the GPU plugin crashed).
282 // If there is a pending asynchronous request, it will be completed by the
Bo Liud1ef1c32017-12-08 06:15:50283 // time this routine returns.
284 scoped_refptr<gpu::GpuChannelHost> EstablishGpuChannelSync();
[email protected]b3e83de2012-02-07 03:33:28285
pimanc44437a22016-10-29 00:09:22286 gpu::GpuMemoryBufferManager* GetGpuMemoryBufferManager();
287
danakjc7afae52017-06-20 21:12:41288 using LayerTreeFrameSinkCallback =
289 base::Callback<void(std::unique_ptr<cc::LayerTreeFrameSink>)>;
290 void RequestNewLayerTreeFrameSink(
danakj83066a32016-06-21 02:34:49291 int routing_id,
292 scoped_refptr<FrameSwapMessageQueue> frame_swap_message_queue,
fsamuelcf3002e2017-03-20 23:13:47293 const GURL& url,
danakjc7afae52017-06-20 21:12:41294 const LayerTreeFrameSinkCallback& callback);
danakj83066a32016-06-21 02:34:49295
Sam McNally52e50282017-11-29 00:54:02296 blink::AssociatedInterfaceRegistry* GetAssociatedInterfaceRegistry();
rockot067ca55f2016-09-30 22:00:15297
jbroman6ccbc7d472016-07-27 04:45:41298 std::unique_ptr<cc::SwapPromise> RequestCopyOfOutputForLayoutTest(
299 int32_t routing_id,
Fady Samueldfecb7d2017-07-26 11:41:04300 std::unique_ptr<viz::CopyOutputRequest> request);
jbroman6ccbc7d472016-07-27 04:45:41301
[email protected]70dee7e2013-05-29 18:28:30302 // True if we are running layout tests. This currently disables forwarding
303 // various status messages to the console, skips network error pages, and
304 // short circuits size update and focus events.
danakj83066a32016-06-21 02:34:49305 bool layout_test_mode() const { return !!layout_test_deps_; }
306 void set_layout_test_dependencies(
307 std::unique_ptr<LayoutTestDependencies> deps) {
308 layout_test_deps_ = std::move(deps);
[email protected]ac7f5a02013-03-16 16:14:41309 }
310
penghuang342762b2016-12-02 21:04:58311 discardable_memory::ClientDiscardableSharedMemoryManager*
312 GetDiscardableSharedMemoryManagerForTest() {
313 return discardable_shared_memory_manager_.get();
314 }
315
tfarina556a7232014-10-05 01:02:09316 RendererBlinkPlatformImpl* blink_platform_impl() const {
317 DCHECK(blink_platform_impl_);
318 return blink_platform_impl_.get();
[email protected]078780b2014-06-20 16:57:06319 }
320
simonhonga7e3ac42014-11-11 20:50:22321 CompositorForwardingMessageFilter* compositor_message_filter() const {
322 return compositor_message_filter_.get();
[email protected]1842fe22012-08-13 23:24:35323 }
324
[email protected]ea5f70a2013-03-07 12:30:36325 InputHandlerManager* input_handler_manager() const {
326 return input_handler_manager_.get();
327 }
328
danakj6e3bf8012014-12-16 18:27:53329 // Will be null if threaded compositing has not been enabled.
skyostil2d3b5bd2015-05-27 15:40:59330 scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner() const {
331 return compositor_task_runner_;
[email protected]a9fb30aa2011-10-06 06:58:46332 }
333
[email protected]f430b5712009-08-21 21:46:31334 AppCacheDispatcher* appcache_dispatcher() const {
335 return appcache_dispatcher_.get();
336 }
337
[email protected]19b49512012-05-30 19:22:09338 DomStorageDispatcher* dom_storage_dispatcher() const {
339 return dom_storage_dispatcher_.get();
340 }
341
[email protected]f7eb0a392011-07-12 10:19:51342 AudioInputMessageFilter* audio_input_message_filter() {
343 return audio_input_message_filter_.get();
344 }
345
John Abd-El-Malekdcf1d1372017-10-22 06:39:41346 FileSystemDispatcher* file_system_dispatcher() const {
347 return file_system_dispatcher_.get();
348 }
349
[email protected]6e068ea2014-02-04 07:05:47350 MidiMessageFilter* midi_message_filter() {
[email protected]a9875152013-06-22 04:03:03351 return midi_message_filter_.get();
352 }
[email protected]6ee10bd2012-09-13 09:01:53353
John Abd-El-Malekf75a3192017-10-22 14:23:20354 QuotaDispatcher* quota_dispatcher() const {
355 return quota_dispatcher_.get();
356 }
357
John Abd-El-Malek6b56ef712017-10-21 22:52:46358 ResourceDispatcher* resource_dispatcher() const {
359 return resource_dispatcher_.get();
360 }
361
Yuzhu Shenfe5f3a52018-01-11 21:24:13362 URLLoaderThrottleProvider* url_loader_throttle_provider() const {
363 return url_loader_throttle_provider_.get();
364 }
365
[email protected]6ca6a082013-09-22 20:10:05366#if defined(OS_ANDROID)
boliubee541f42015-11-05 00:52:53367 SynchronousCompositorFilter* sync_compositor_message_filter() {
368 return sync_compositor_message_filter_.get();
369 }
siva.gunturi5d4feb052015-11-15 16:15:31370
371 scoped_refptr<StreamTextureFactory> GetStreamTexureFactory();
boliuf8753bf62016-02-11 20:09:42372 bool EnableStreamTextureCopy();
[email protected]6ca6a082013-09-22 20:10:05373#endif
374
[email protected]d8cd8372012-03-09 10:49:51375 // Creates the embedder implementation of WebMediaStreamCenter.
376 // The resulting object is owned by WebKit and deleted by WebKit at tear-down.
altimineb6bd1962017-05-03 14:52:38377 std::unique_ptr<blink::WebMediaStreamCenter> CreateMediaStreamCenter(
[email protected]180ef242013-11-07 06:50:46378 blink::WebMediaStreamCenterClient* client);
[email protected]d8cd8372012-03-09 10:49:51379
fsamuel6c1dfeb2014-12-18 19:21:33380 BrowserPluginManager* browser_plugin_manager() const {
381 return browser_plugin_manager_.get();
382 }
383
Brett Wilson0748bf412016-11-22 17:55:46384#if BUILDFLAG(ENABLE_WEBRTC)
[email protected]6ee10bd2012-09-13 09:01:53385 // Returns a factory used for creating RTC PeerConnection objects.
[email protected]0107d8a2014-05-16 10:20:34386 PeerConnectionDependencyFactory* GetPeerConnectionDependencyFactory();
[email protected]6ee10bd2012-09-13 09:01:53387
[email protected]af089972013-01-10 04:04:40388 PeerConnectionTracker* peer_connection_tracker() {
389 return peer_connection_tracker_.get();
390 }
391
[email protected]4761cf12012-09-12 10:37:55392 // Current P2PSocketDispatcher. Set to NULL if P2P API is disabled.
[email protected]e9ff79c2012-10-19 21:31:26393 P2PSocketDispatcher* p2p_socket_dispatcher() {
[email protected]4761cf12012-09-12 10:37:55394 return p2p_socket_dispatcher_.get();
395 }
[email protected]22fe91d2014-08-12 17:07:12396#endif
[email protected]4761cf12012-09-12 10:37:55397
[email protected]80b161a2011-06-27 17:42:11398 VideoCaptureImplManager* video_capture_impl_manager() const {
399 return vc_manager_.get();
400 }
401
danakj92429852017-06-29 00:19:03402 viz::ClientSharedBitmapManager* shared_bitmap_manager() const {
jcivelli0f21bd52016-12-07 21:21:33403 DCHECK(shared_bitmap_manager_);
404 return shared_bitmap_manager_.get();
405 }
406
John Abd-El-Malekf9f86c12017-10-21 07:22:23407 NotificationDispatcher* notification_dispatcher() const {
408 return notification_dispatcher_.get();
409 }
410
rockot1587e332016-07-27 17:44:14411 mojom::RenderFrameMessageFilter* render_frame_message_filter();
rockote261d2112016-09-21 22:22:23412 mojom::RenderMessageFilter* render_message_filter();
rockot1587e332016-07-27 17:44:14413
[email protected]6217d392010-03-25 22:08:35414 // Get the GPU channel. Returns NULL if the channel is not established or
415 // has been lost.
penghuang346a46f92016-03-31 21:37:52416 gpu::GpuChannelHost* GetGpuChannel();
[email protected]6217d392010-03-25 22:08:35417
skyostil2d3b5bd2015-05-27 15:40:59418 // Returns a SingleThreadTaskRunner instance corresponding to the message loop
[email protected]c6a7b862010-08-20 22:19:38419 // of the thread on which file operations should be run. Must be called
420 // on the renderer's main thread.
Marijn Kruisselbrink8c276412017-07-29 06:11:21421 scoped_refptr<base::TaskRunner> GetFileThreadTaskRunner();
[email protected]c6a7b862010-08-20 22:19:38422
acolwellb4034942014-08-28 15:42:43423 // Returns a SingleThreadTaskRunner instance corresponding to the message loop
[email protected]c1330c82013-06-06 02:23:25424 // of the thread on which media operations should be run. Must be called
425 // on the renderer's main thread.
acolwellb4034942014-08-28 15:42:43426 scoped_refptr<base::SingleThreadTaskRunner> GetMediaThreadTaskRunner();
[email protected]c1330c82013-06-06 02:23:25427
dcastagna4517a182015-08-05 19:51:03428 // A TaskRunner instance that runs tasks on the raster worker pool.
429 base::TaskRunner* GetWorkerTaskRunner();
dcastagnab880e8f2015-06-30 20:16:06430
danakj0b4b94e32016-05-10 22:33:01431 // Returns a worker context provider that will be bound on the compositor
432 // thread.
Victor Miuraff6488612017-12-21 04:16:15433 scoped_refptr<viz::RasterContextProvider>
danakj0b4b94e32016-05-10 22:33:01434 SharedCompositorWorkerContextProvider();
revemand180dfc32015-09-24 00:19:43435
[email protected]1784b2f2011-11-24 10:53:48436 // Causes the idle handler to skip sending idle notifications
437 // on the two next scheduled calls, so idle notifications are
438 // not sent for at least one notification delay.
439 void PostponeIdleNotification();
440
dcastagna7f45dada2015-10-19 20:17:35441 media::GpuVideoAcceleratorFactories* GetGpuFactories();
[email protected]3bb8bb32013-07-11 13:13:03442
sadrul85cc5d82016-12-20 03:37:41443 scoped_refptr<ui::ContextProviderCommandBuffer>
444 SharedMainThreadContextProvider();
[email protected]c29b7ff2013-03-06 03:51:04445
[email protected]3958e972012-07-17 00:25:41446 // AudioRendererMixerManager instance which manages renderer side mixer
447 // instances shared based on configured audio parameters. Lazily created on
448 // first call.
[email protected]e9ff79c2012-10-19 21:31:26449 AudioRendererMixerManager* GetAudioRendererMixerManager();
[email protected]3958e972012-07-17 00:25:41450
[email protected]feb32372012-11-21 01:14:56451#if defined(OS_WIN)
[email protected]fcf75d42013-12-03 20:11:26452 void PreCacheFontCharacters(const LOGFONT& log_font,
453 const base::string16& str);
[email protected]feb32372012-11-21 01:14:56454#endif
455
[email protected]b2d98762012-09-03 17:04:06456 // For producing custom V8 histograms. Custom histograms are produced if all
457 // RenderViews share the same host, and the host is in the pre-specified set
458 // of hosts we want to produce custom diagrams for. The name for a custom
459 // diagram is the name of the corresponding generic diagram plus a
460 // host-specific suffix.
461 class CONTENT_EXPORT HistogramCustomizer {
462 public:
463 HistogramCustomizer();
464 ~HistogramCustomizer();
465
466 // Called when a top frame of a RenderView navigates. This function updates
467 // RenderThreadImpl's information about whether all RenderViews are
468 // displaying a page from the same host. |host| is the host where a
469 // RenderView navigated, and |view_count| is the number of RenderViews in
470 // this process.
471 void RenderViewNavigatedToHost(const std::string& host, size_t view_count);
472
473 // Used for customizing some histograms if all RenderViews share the same
474 // host. Returns the current custom histogram name to use for
475 // |histogram_name|, or |histogram_name| if it shouldn't be customized.
476 std::string ConvertToCustomHistogramName(const char* histogram_name) const;
477
478 private:
hablichd6a4f122015-10-28 11:34:49479 FRIEND_TEST_ALL_PREFIXES(RenderThreadImplUnittest,
480 IdentifyAlexaTop10NonGoogleSite);
[email protected]b2d98762012-09-03 17:04:06481 friend class RenderThreadImplUnittest;
482
hablichd6a4f122015-10-28 11:34:49483 // Converts a host name to a suffix for histograms
484 std::string HostToCustomHistogramSuffix(const std::string& host);
485
486 // Helper function to identify a certain set of top pages
487 bool IsAlexaTop10NonGoogleSite(const std::string& host);
488
[email protected]b2d98762012-09-03 17:04:06489 // Used for updating the information on which is the common host which all
490 // RenderView's share (if any). If there is no common host, this function is
491 // called with an empty string.
492 void SetCommonHost(const std::string& host);
493
494 // The current common host of the RenderViews; empty string if there is no
495 // common host.
496 std::string common_host_;
497 // The corresponding suffix.
498 std::string common_host_histogram_suffix_;
499 // Set of histograms for which we want to produce a custom histogram if
500 // possible.
501 std::set<std::string> custom_histograms_;
502
503 DISALLOW_COPY_AND_ASSIGN(HistogramCustomizer);
504 };
505
506 HistogramCustomizer* histogram_customizer() {
507 return &histogram_customizer_;
508 }
509
[email protected]ca998e5e2013-08-06 14:59:09510 // Retrieve current gamepad data.
juncai2f298a82017-04-18 03:51:39511 void SampleGamepads(device::Gamepads* data);
[email protected]ca998e5e2013-08-06 14:59:09512
[email protected]b2db9272014-01-10 17:42:00513 // Called by a RenderWidget when it is created or destroyed. This
514 // allows the process to know when there are no visible widgets.
515 void WidgetCreated();
rmcilroyaa296052015-04-14 15:35:27516 // Note: A widget must not be hidden when it is destroyed - ensure that
517 // WidgetRestored is called before WidgetDestroyed for any hidden widget.
[email protected]b2db9272014-01-10 17:42:00518 void WidgetDestroyed();
519 void WidgetHidden();
520 void WidgetRestored();
521
benf28ce882017-05-02 16:15:49522 void RegisterPendingFrameCreate(
523 const service_manager::BindSourceInfo& source_info,
524 int routing_id,
Balazs Engedyba034e72017-10-27 22:26:28525 mojom::FrameRequest frame);
rockotf8fdd9b2015-12-16 22:22:35526
leon.han06e55662016-03-26 17:19:42527 mojom::StoragePartitionService* GetStoragePartitionService();
jam188f19f2017-06-07 03:56:24528 mojom::RendererHost* GetRendererHost();
jamc912ca32016-02-24 20:17:31529
bashia6264042016-09-15 04:49:51530 // ChildMemoryCoordinatorDelegate implementation.
bashic4b4afcb2016-08-23 06:37:52531 void OnTrimMemoryImmediately() override;
532
keishi51ed0d52017-01-12 10:04:46533 struct RendererMemoryMetrics {
534 size_t partition_alloc_kb;
535 size_t blink_gc_kb;
536 size_t malloc_mb;
537 size_t discardable_kb;
538 size_t v8_main_thread_isolate_mb;
539 size_t total_allocated_mb;
540 size_t non_discardable_total_allocated_mb;
541 size_t total_allocated_per_render_view_mb;
542 };
bashia0ba0d42017-04-03 08:11:06543 bool GetRendererMemoryMetrics(RendererMemoryMetrics* memory_metrics) const;
keishi51ed0d52017-01-12 10:04:46544
Takashi SAKAMOTO870f6262017-08-22 04:08:27545 bool NeedsToRecordFirstActivePaint(int metric_type) const;
tasakb95dbb50c2017-02-08 18:07:50546
Miguel Casas5e1018052018-01-09 19:17:36547 // Sets the current pipeline rendering color space.
548 void SetRenderingColorSpace(const gfx::ColorSpace& color_space);
549
alexclarke0bc36e8d32014-12-17 17:29:20550 protected:
jam75c44222016-03-23 05:34:24551 RenderThreadImpl(
552 const InProcessChildThreadParams& params,
skyostil529caa292016-08-10 17:44:51553 std::unique_ptr<blink::scheduler::RendererScheduler> scheduler,
rockot97a86832016-12-10 04:53:06554 const scoped_refptr<base::SingleThreadTaskRunner>& resource_task_queue);
skyostil529caa292016-08-10 17:44:51555 RenderThreadImpl(
556 std::unique_ptr<base::MessageLoop> main_message_loop,
557 std::unique_ptr<blink::scheduler::RendererScheduler> scheduler);
alexclarke0bc36e8d32014-12-17 17:29:20558
[email protected]8930d472009-02-21 08:05:28559 private:
Nicholas Verne06de8122017-11-16 04:47:38560 void OnProcessFinalRelease() override;
torne88b66452016-05-03 13:22:14561 // IPC::Listener
562 void OnChannelError() override;
563
[email protected]57cf97882013-06-26 20:39:01564 // ChildThread
dcheng6d18e402014-10-21 12:32:52565 bool OnControlMessageReceived(const IPC::Message& msg) override;
liberato3aeeb2c2016-02-25 17:54:38566 void RecordAction(const base::UserMetricsAction& action) override;
567 void RecordComputedAction(const std::string& action) override;
initial.commit09911bf2008-07-26 23:55:29568
sadrul53546592016-12-17 01:44:21569 bool IsMainThread();
[email protected]57cf97882013-06-26 20:39:01570
hajimehoshi7bb39582016-10-12 04:30:57571 // base::MemoryCoordinatorClient implementation:
572 void OnMemoryStateChange(base::MemoryState state) override;
bashi233f65e2017-02-09 08:36:03573 void OnPurgeMemory() override;
hajimehoshi7bb39582016-10-12 04:30:57574
bashib9058f282017-03-30 01:55:24575 void RecordPurgeMemory(RendererMemoryMetrics before);
576
hajimehoshi7bb39582016-10-12 04:30:57577 void ClearMemory();
578
rockot97a86832016-12-10 04:53:06579 void Init(
580 const scoped_refptr<base::SingleThreadTaskRunner>& resource_task_queue);
initial.commit09911bf2008-07-26 23:55:29581
vollick1050cc62015-12-03 07:04:54582 void InitializeCompositorThread();
583
jam75c44222016-03-23 05:34:24584 void InitializeWebKit(
Stuart Langley7b8dc772017-10-31 03:55:20585 const scoped_refptr<base::SingleThreadTaskRunner>& resource_task_queue,
Ken Rockot510c5972017-12-05 16:37:04586 service_manager::BinderRegistry* registry);
jam75c44222016-03-23 05:34:24587
initial.commit09911bf2008-07-26 23:55:29588 void OnTransferBitmap(const SkBitmap& bitmap, int resource_id);
[email protected]b3df5a42010-05-11 14:31:09589 void OnGetAccessibilityTree();
blundellc00adf442016-09-16 10:43:41590
rockot067ca55f2016-09-30 22:00:15591 // mojom::Renderer:
592 void CreateView(mojom::CreateViewParamsPtr params) override;
rockot53be7caf2016-10-04 20:17:08593 void CreateFrame(mojom::CreateFrameParamsPtr params) override;
Makoto Shimazu7af43ee2017-08-25 10:20:40594 void SetUpEmbeddedWorkerChannelForServiceWorker(
595 mojom::EmbeddedWorkerInstanceClientAssociatedRequest client_request)
596 override;
rockot53be7caf2016-10-04 20:17:08597 void CreateFrameProxy(int32_t routing_id,
598 int32_t render_view_routing_id,
599 int32_t opener_routing_id,
600 int32_t parent_routing_id,
601 const FrameReplicationState& replicated_state) override;
rockota2db0da2016-10-18 17:39:11602 void OnNetworkConnectionChanged(
603 net::NetworkChangeNotifier::ConnectionType type,
604 double max_bandwidth_mbps) override;
tbansalb612c5d2017-05-25 18:53:06605 void OnNetworkQualityChanged(net::EffectiveConnectionType type,
606 base::TimeDelta http_rtt,
tbansal99d8aeb2017-05-22 19:12:58607 base::TimeDelta transport_rtt,
tbansal15973c32017-05-10 18:40:44608 double bandwidth_kbps) override;
rockota2db0da2016-10-18 17:39:11609 void SetWebKitSharedTimersSuspended(bool suspend) override;
610 void UpdateScrollbarTheme(
611 mojom::UpdateScrollbarThemeParamsPtr params) override;
612 void OnSystemColorsChanged(int32_t aqua_color_variant,
613 const std::string& highlight_text_color,
614 const std::string& highlight_color) override;
615 void PurgePluginListCache(bool reload_pages) override;
Nicholas Verne5420564d2017-10-27 07:37:54616 void SetProcessBackgrounded(bool backgrounded) override;
617 void ProcessPurgeAndSuspend() override;
rockot067ca55f2016-09-30 22:00:15618
[email protected]5071cb22013-07-10 02:19:06619 void OnMemoryPressure(
620 base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level);
rockota2db0da2016-10-18 17:39:11621
rmcilroyaa296052015-04-14 15:35:27622 bool RendererIsHidden() const;
623 void OnRendererHidden();
624 void OnRendererVisible();
[email protected]b3df5a42010-05-11 14:31:09625
tasak335a1872017-06-14 09:50:23626 void RecordMemoryUsageAfterBackgrounded(const char* suffix,
627 int foregrounded_count);
tasakbb0640b2017-05-15 09:02:26628 void RecordPurgeAndSuspendMemoryGrowthMetrics(
629 const char* suffix,
630 int foregrounded_count_when_purged);
tasakb46626a2016-10-18 05:54:44631
ssid0603ca9f2015-06-09 16:48:08632 void ReleaseFreeMemory();
633
hong.zhengb28b5332016-05-11 02:33:39634 void OnSyncMemoryPressure(
635 base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level);
636
Fady Samuelc645ffe2017-07-24 17:28:20637 std::unique_ptr<viz::BeginFrameSource> CreateExternalBeginFrameSource(
enne077ba4862016-09-12 20:59:53638 int routing_id);
639
Fady Samuelc645ffe2017-07-24 17:28:20640 std::unique_ptr<viz::SyntheticBeginFrameSource>
samans09812d32017-03-27 19:51:50641 CreateSyntheticBeginFrameSource();
642
rockot067ca55f2016-09-30 22:00:15643 void OnRendererInterfaceRequest(mojom::RendererAssociatedRequest request);
644
penghuang342762b2016-12-02 21:04:58645 std::unique_ptr<discardable_memory::ClientDiscardableSharedMemoryManager>
646 discardable_shared_memory_manager_;
647
initial.commit09911bf2008-07-26 23:55:29648 // These objects live solely on the render thread.
dchengcedca5612016-04-09 01:40:15649 std::unique_ptr<AppCacheDispatcher> appcache_dispatcher_;
650 std::unique_ptr<DomStorageDispatcher> dom_storage_dispatcher_;
651 std::unique_ptr<IndexedDBDispatcher> main_thread_indexed_db_dispatcher_;
skyostil529caa292016-08-10 17:44:51652 std::unique_ptr<blink::scheduler::RendererScheduler> renderer_scheduler_;
dchengcedca5612016-04-09 01:40:15653 std::unique_ptr<RendererBlinkPlatformImpl> blink_platform_impl_;
John Abd-El-Malek6b56ef712017-10-21 22:52:46654 std::unique_ptr<ResourceDispatcher> resource_dispatcher_;
dchengcedca5612016-04-09 01:40:15655 std::unique_ptr<CacheStorageDispatcher> main_thread_cache_storage_dispatcher_;
John Abd-El-Malekdcf1d1372017-10-22 06:39:41656 std::unique_ptr<FileSystemDispatcher> file_system_dispatcher_;
John Abd-El-Malekf75a3192017-10-22 14:23:20657 std::unique_ptr<QuotaDispatcher> quota_dispatcher_;
Yuzhu Shenfe5f3a52018-01-11 21:24:13658 std::unique_ptr<URLLoaderThrottleProvider> url_loader_throttle_provider_;
[email protected]9291ed12009-07-23 17:33:22659
[email protected]e2b2d4a2009-10-24 03:32:59660 // Used on the renderer and IPC threads.
dmurph1fb98482016-03-30 21:14:26661 scoped_refptr<BlobMessageFilter> blob_message_filter_;
[email protected]f7eb0a392011-07-12 10:19:51662 scoped_refptr<AudioInputMessageFilter> audio_input_message_filter_;
[email protected]6e068ea2014-02-04 07:05:47663 scoped_refptr<MidiMessageFilter> midi_message_filter_;
John Abd-El-Maleke1d4de32017-10-21 16:14:29664 scoped_refptr<ServiceWorkerMessageFilter> service_worker_message_filter_;
[email protected]017022b2009-07-27 23:06:34665
dchengcedca5612016-04-09 01:40:15666 std::unique_ptr<BrowserPluginManager> browser_plugin_manager_;
fsamuel6c1dfeb2014-12-18 19:21:33667
Brett Wilson0748bf412016-11-22 17:55:46668#if BUILDFLAG(ENABLE_WEBRTC)
dchengcedca5612016-04-09 01:40:15669 std::unique_ptr<PeerConnectionDependencyFactory> peer_connection_factory_;
[email protected]6ee10bd2012-09-13 09:01:53670
[email protected]af089972013-01-10 04:04:40671 // This is used to communicate to the browser process the status
672 // of all the peer connections created in the renderer.
dchengcedca5612016-04-09 01:40:15673 std::unique_ptr<PeerConnectionTracker> peer_connection_tracker_;
[email protected]af089972013-01-10 04:04:40674
[email protected]4761cf12012-09-12 10:37:55675 // Dispatches all P2P sockets.
[email protected]e9ff79c2012-10-19 21:31:26676 scoped_refptr<P2PSocketDispatcher> p2p_socket_dispatcher_;
[email protected]80b161a2011-06-27 17:42:11677
[email protected]da9f30a2014-06-18 19:39:04678 // Used for communicating registering AEC dump consumers with the browser and
679 // receving AEC dump file handles when AEC dump is enabled. An AEC dump is
680 // diagnostic audio data for WebRTC stored locally when enabled by the user in
681 // chrome://webrtc-internals.
682 scoped_refptr<AecDumpMessageFilter> aec_dump_message_filter_;
liushouqun517b1292016-09-14 05:58:59683#endif
684
maxmorin017ba8c62017-06-02 10:23:09685 // Provides AudioOutputIPC objects for audio output devices. It either uses
686 // an AudioMessageFilter for this or provides MojoAudioOutputIPC objects.
687 // Initialized in Init.
688 base::Optional<AudioIPCFactory> audio_ipc_factory_;
689
liushouqun517b1292016-09-14 05:58:59690 // Used on the render thread.
691 std::unique_ptr<VideoCaptureImplManager> vc_manager_;
[email protected]da9f30a2014-06-18 19:39:04692
danakj92429852017-06-29 00:19:03693 std::unique_ptr<viz::ClientSharedBitmapManager> shared_bitmap_manager_;
jcivelli0f21bd52016-12-07 21:21:33694
John Abd-El-Malekf9f86c12017-10-21 07:22:23695 scoped_refptr<NotificationDispatcher> notification_dispatcher_;
696
Makoto Shimazu7af43ee2017-08-25 10:20:40697 // The time Blink was initialized. Used for UMA.
698 base::TimeTicks blink_initialized_time_;
699
[email protected]bee16aab2009-08-26 15:55:03700 // The count of RenderWidgets running through this thread.
701 int widget_count_;
702
703 // The count of hidden RenderWidgets running through this thread.
704 int hidden_widget_count_;
705
706 // The current value of the idle notification timer delay.
avi1023d012015-12-25 02:39:14707 int64_t idle_notification_delay_in_ms_;
[email protected]bee16aab2009-08-26 15:55:03708
[email protected]1784b2f2011-11-24 10:53:48709 // The number of idle handler calls that skip sending idle notifications.
710 int idle_notifications_to_skip_;
711
Alexander Timin4b6152232017-10-17 20:34:06712 bool webkit_shared_timer_suspended_;
[email protected]c1f50aa2010-02-18 03:46:57713
danakj83066a32016-06-21 02:34:49714 // Used to control layout test specific behavior.
715 std::unique_ptr<LayoutTestDependencies> layout_test_deps_;
[email protected]233567d2013-02-27 20:22:02716
[email protected]71d6d852009-12-07 22:12:36717 // Timer that periodically calls IdleHandler.
danakj8c3eb802015-09-24 07:53:00718 base::RepeatingTimer idle_timer_;
[email protected]71d6d852009-12-07 22:12:36719
danakjab9ef4d2017-10-31 23:38:33720 // Sticky once true, indicates that compositing is done without Gpu, so
721 // resources given to the compositor or to the viz service should be
722 // software-based.
723 bool is_gpu_compositing_disabled_ = false;
724
haraken53f081d2014-11-11 01:03:40725 // The message loop of the renderer main thread.
726 // This message loop should be destructed before the RenderThreadImpl
727 // shuts down Blink.
dchengcedca5612016-04-09 01:40:15728 std::unique_ptr<base::MessageLoop> main_message_loop_;
haraken53f081d2014-11-11 01:03:40729
[email protected]ea5f70a2013-03-07 12:30:36730 // May be null if overridden by ContentRendererClient.
skyostil529caa292016-08-10 17:44:51731 std::unique_ptr<blink::scheduler::WebThreadBase> compositor_thread_;
[email protected]ea5f70a2013-03-07 12:30:36732
dcastagna7f45dada2015-10-19 20:17:35733 // Utility class to provide GPU functionalities to media.
dcastagna09bd6b32016-02-01 21:54:28734 // TODO(dcastagna): This should be just one scoped_ptr once
735 // http://crbug.com/580386 is fixed.
736 // NOTE(dcastagna): At worst this accumulates a few bytes per context lost.
Miguel Casas-Sanchezcfcca5d52017-07-07 02:32:59737 std::vector<std::unique_ptr<GpuVideoAcceleratorFactoriesImpl>> gpu_factories_;
dcastagna7f45dada2015-10-19 20:17:35738
[email protected]c1330c82013-06-06 02:23:25739 // Thread for running multimedia operations (e.g., video decoding).
dchengcedca5612016-04-09 01:40:15740 std::unique_ptr<base::Thread> media_thread_;
[email protected]c1330c82013-06-06 02:23:25741
skyostil2d3b5bd2015-05-27 15:40:59742 // Will point to appropriate task runner after initialization,
[email protected]ea5f70a2013-03-07 12:30:36743 // regardless of whether |compositor_thread_| is overriden.
skyostil2d3b5bd2015-05-27 15:40:59744 scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner_;
[email protected]ea5f70a2013-03-07 12:30:36745
dcastagnab880e8f2015-06-30 20:16:06746 // Pool of workers used for raster operations (e.g., tile rasterization).
prashant.nfad657e2016-06-01 07:52:17747 scoped_refptr<CategorizedWorkerPool> categorized_worker_pool_;
reveman34b7a1522015-03-23 20:27:47748
jdduke691dd572014-12-02 20:47:52749 base::CancelableCallback<void(const IPC::Message&)> main_input_callback_;
750 scoped_refptr<IPC::MessageFilter> input_event_filter_;
dchengcedca5612016-04-09 01:40:15751 std::unique_ptr<InputHandlerManager> input_handler_manager_;
simonhonga7e3ac42014-11-11 20:50:22752 scoped_refptr<CompositorForwardingMessageFilter> compositor_message_filter_;
[email protected]1842fe22012-08-13 23:24:35753
boliubee541f42015-11-05 00:52:53754#if defined(OS_ANDROID)
755 scoped_refptr<SynchronousCompositorFilter> sync_compositor_message_filter_;
siva.gunturi5d4feb052015-11-15 16:15:31756 scoped_refptr<StreamTextureFactory> stream_texture_factory_;
boliubee541f42015-11-05 00:52:53757#endif
758
sadrul85cc5d82016-12-20 03:37:41759 scoped_refptr<ui::ContextProviderCommandBuffer> shared_main_thread_contexts_;
[email protected]c29b7ff2013-03-06 03:51:04760
tyoshino832a58a2016-04-18 08:14:08761 base::ObserverList<RenderThreadObserver> observers_;
[email protected]1223d6ef2011-03-28 16:47:50762
Victor Miuraff6488612017-12-21 04:16:15763 scoped_refptr<viz::RasterContextProvider> shared_worker_context_provider_;
[email protected]3b2afc32012-06-18 21:31:16764
dchengcedca5612016-04-09 01:40:15765 std::unique_ptr<AudioRendererMixerManager> audio_renderer_mixer_manager_;
[email protected]3958e972012-07-17 00:25:41766
[email protected]b2d98762012-09-03 17:04:06767 HistogramCustomizer histogram_customizer_;
768
dchengcedca5612016-04-09 01:40:15769 std::unique_ptr<base::MemoryPressureListener> memory_pressure_listener_;
[email protected]5071cb22013-07-10 02:19:06770
bashia6264042016-09-15 04:49:51771 std::unique_ptr<ChildMemoryCoordinatorImpl> memory_coordinator_;
[email protected]fdeac262014-07-10 12:52:51772
sadrul04cfa892016-12-09 17:53:49773 std::unique_ptr<ui::Gpu> gpu_;
sadrul9e0bb1d2016-08-04 20:18:39774
skyostil457b0a12014-09-09 10:12:07775 scoped_refptr<base::SingleThreadTaskRunner>
776 main_thread_compositor_task_runner_;
skyostil457b0a12014-09-09 10:12:07777
danakj6e3bf8012014-12-16 18:27:53778 // Compositor settings.
[email protected]a23530d2014-03-11 06:04:14779 bool is_gpu_rasterization_forced_;
senorblancob60ba952015-01-27 19:12:36780 int gpu_rasterization_msaa_sample_count_;
[email protected]a23530d2014-03-11 06:04:14781 bool is_lcd_text_enabled_;
[email protected]b242b142014-05-07 14:48:49782 bool is_distance_field_text_enabled_;
[email protected]2cccfef2014-05-01 06:05:16783 bool is_zero_copy_enabled_;
ccameronc7fcd132015-11-03 20:14:31784 bool is_gpu_memory_buffer_compositor_resources_enabled_;
ericrk1d17f752015-10-20 03:03:07785 bool is_partial_raster_enabled_;
ccamerona7644752014-12-30 01:16:31786 bool is_elastic_overscroll_enabled_;
loyso65c93c602015-08-11 05:15:57787 bool is_threaded_animation_enabled_;
wjmaclean1d970622017-01-21 22:28:24788 bool is_scroll_animator_enabled_;
[email protected]a23530d2014-03-11 06:04:14789
Miguel Casas5e1018052018-01-09 19:17:36790 // Target rendering ColorSpace.
791 gfx::ColorSpace rendering_color_space_;
792
ben76f52b242016-06-18 05:42:48793 class PendingFrameCreate : public base::RefCounted<PendingFrameCreate> {
rockotf8fdd9b2015-12-16 22:22:35794 public:
Balazs Engedyba034e72017-10-27 22:26:28795 PendingFrameCreate(const service_manager::BindSourceInfo& source_info,
796 int routing_id,
797 mojom::FrameRequest frame_request);
rockotf8fdd9b2015-12-16 22:22:35798
benf28ce882017-05-02 16:15:49799 const service_manager::BindSourceInfo& browser_info() const {
800 return browser_info_;
801 }
ben76f52b242016-06-18 05:42:48802 mojom::FrameRequest TakeFrameRequest() { return std::move(frame_request_); }
rockotf8fdd9b2015-12-16 22:22:35803
804 private:
ben76f52b242016-06-18 05:42:48805 friend class base::RefCounted<PendingFrameCreate>;
rockotf8fdd9b2015-12-16 22:22:35806
ben76f52b242016-06-18 05:42:48807 ~PendingFrameCreate();
rockotf8fdd9b2015-12-16 22:22:35808
809 // Mojo error handler.
810 void OnConnectionError();
811
benf28ce882017-05-02 16:15:49812 service_manager::BindSourceInfo browser_info_;
rockotf8fdd9b2015-12-16 22:22:35813 int routing_id_;
ben76f52b242016-06-18 05:42:48814 mojom::FrameRequest frame_request_;
rockotf8fdd9b2015-12-16 22:22:35815 };
816
ben76f52b242016-06-18 05:42:48817 using PendingFrameCreateMap =
818 std::map<int, scoped_refptr<PendingFrameCreate>>;
819 PendingFrameCreateMap pending_frame_creates_;
rockotf8fdd9b2015-12-16 22:22:35820
leon.han06e55662016-03-26 17:19:42821 mojom::StoragePartitionServicePtr storage_partition_service_;
Joel Hockey3146d142017-11-15 22:27:40822 mojom::RendererHostAssociatedPtr renderer_host_;
jamc912ca32016-02-24 20:17:31823
rockot067ca55f2016-09-30 22:00:15824 AssociatedInterfaceRegistryImpl associated_interfaces_;
825
826 mojo::AssociatedBinding<mojom::Renderer> renderer_binding_;
827
rockot1587e332016-07-27 17:44:14828 mojom::RenderFrameMessageFilterAssociatedPtr render_frame_message_filter_;
rockote261d2112016-09-21 22:22:23829 mojom::RenderMessageFilterAssociatedPtr render_message_filter_;
rockot1587e332016-07-27 17:44:14830
tasak72f64042017-01-19 14:02:53831 RendererMemoryMetrics purge_and_suspend_memory_metrics_;
tasakb95dbb50c2017-02-08 18:07:50832 bool needs_to_record_first_active_paint_;
Takashi SAKAMOTO870f6262017-08-22 04:08:27833 base::TimeTicks was_backgrounded_time_;
tasakbb0640b2017-05-15 09:02:26834 int process_foregrounded_count_;
hajimehoshi69093272016-05-13 08:30:58835
staraz067f58242016-11-07 21:06:41836 int32_t client_id_;
837
samans2040988b2017-04-11 23:58:35838 mojom::FrameSinkProviderPtr frame_sink_provider_;
839
danakjab9ef4d2017-10-31 23:38:33840 // A mojo connection to the CompositingModeReporter service.
841 viz::mojom::CompositingModeReporterPtr compositing_mode_reporter_;
842 // The class is a CompositingModeWatcher, which is bound to mojo through
danakj4ee301c2017-11-29 16:19:43843 // this member.
danakjab9ef4d2017-10-31 23:38:33844 mojo::Binding<viz::mojom::CompositingModeWatcher>
845 compositing_mode_watcher_binding_;
846
[email protected]f1a29a02011-10-06 23:08:44847 DISALLOW_COPY_AND_ASSIGN(RenderThreadImpl);
initial.commit09911bf2008-07-26 23:55:29848};
849
jam8a021512a2015-02-03 18:16:08850#if defined(COMPILER_MSVC)
851#pragma warning(pop)
852#endif
853
[email protected]e9ff79c2012-10-19 21:31:26854} // namespace content
855
[email protected]f1a29a02011-10-06 23:08:44856#endif // CONTENT_RENDERER_RENDER_THREAD_IMPL_H_