blob: e612be48aeca6645b248343aea7b8944734fcb10 [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"
Gordon Guan96c21ee2019-11-06 15:05:3920#include "base/memory/discardable_memory_allocator.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"
tbansal99d8aeb2017-05-22 19:12:5827#include "base/time/time.h"
[email protected]037fce02009-01-22 01:42:1528#include "build/build_config.h"
jam8a021512a2015-02-03 18:16:0829#include "content/child/child_thread_impl.h"
[email protected]8d128d62011-09-13 22:11:5730#include "content/common/content_export.h"
ben76f52b242016-06-18 05:42:4831#include "content/common/frame.mojom.h"
alexmosbc7eafa2014-12-06 01:38:0932#include "content/common/frame_replication_state.h"
samans2040988b2017-04-11 23:58:3533#include "content/common/frame_sink_provider.mojom.h"
jonrossa2ff4f82018-02-16 17:27:4634#include "content/common/render_frame_metadata.mojom.h"
rockote261d2112016-09-21 22:22:2335#include "content/common/render_message_filter.mojom.h"
rockot067ca55f2016-09-30 22:00:1536#include "content/common/renderer.mojom.h"
jam188f19f2017-06-07 03:56:2437#include "content/common/renderer_host.mojom.h"
[email protected]526476902011-10-06 20:34:0638#include "content/public/renderer/render_thread.h"
Yuzhu Shenfe5f3a52018-01-11 21:24:1339#include "content/public/renderer/url_loader_throttle_provider.h"
Sadrul Habib Chowdhury31c98712018-12-11 04:15:1340#include "content/renderer/compositor/compositor_dependencies.h"
Gordon Guan96c21ee2019-11-06 15:05:3941#include "content/renderer/discardable_memory_utils.h"
Amos Limbcc710e2018-06-08 05:51:1742#include "content/renderer/media/audio/audio_input_ipc_factory.h"
43#include "content/renderer/media/audio/audio_output_ipc_factory.h"
penghuang346a46f92016-03-31 21:37:5244#include "gpu/ipc/client/gpu_channel_host.h"
Antoine Laboure55c9ef82017-11-10 18:51:2345#include "ipc/ipc_sync_channel.h"
Scott Violeta35f9a42018-03-22 22:00:4446#include "media/media_buildflags.h"
Julie Jeongeun Kim4e77af2622019-09-11 03:36:4547#include "mojo/public/cpp/bindings/associated_receiver.h"
Julie Jeongeun Kimdaa9aa12019-10-24 02:51:5648#include "mojo/public/cpp/bindings/associated_remote.h"
Julie Jeongeun Kim4e77af2622019-09-11 03:36:4549#include "mojo/public/cpp/bindings/pending_associated_receiver.h"
Julie Jeongeun Kim4421c2e2019-09-11 06:34:3950#include "mojo/public/cpp/bindings/pending_receiver.h"
Julie Jeongeun Kim6f4b7e02019-09-11 05:05:4651#include "mojo/public/cpp/bindings/pending_remote.h"
Gyuyoung Kimef648a2e72019-09-17 09:48:3552#include "mojo/public/cpp/bindings/receiver.h"
Mario Sanchez Prada5492c9a2019-09-10 20:58:1153#include "mojo/public/cpp/bindings/remote.h"
[email protected]d7ff5fb2014-05-29 19:50:2554#include "net/base/network_change_notifier.h"
tbansalb612c5d2017-05-25 18:53:0655#include "net/nqe/effective_connection_type.h"
Ken Rockot54311e62018-02-10 19:01:5256#include "services/network/public/mojom/url_loader_factory.mojom.h"
Miyoung Shin99505dd2019-07-27 12:45:3557#include "services/viz/public/mojom/compositing/compositing_mode_watcher.mojom.h"
Ken Rockot26e4e802018-07-31 15:03:3358#include "third_party/blink/public/common/associated_interfaces/associated_interface_registry.h"
Mike West6e4cbb32019-02-13 09:40:1759#include "third_party/blink/public/common/user_agent/user_agent_metadata.h"
Kent Tamura38fb4342018-07-25 12:47:5360#include "third_party/blink/public/platform/scheduler/web_rail_mode_observer.h"
Daniel Murphy738378c2019-05-31 21:59:2561#include "third_party/blink/public/platform/scheduler/web_thread_scheduler.h"
Blink Reformata30d4232018-04-07 15:31:0662#include "third_party/blink/public/platform/web_connection_type.h"
63#include "third_party/blink/public/web/web_memory_statistics.h"
[email protected]08397d52011-02-05 01:53:3864#include "ui/gfx/native_widget_types.h"
initial.commit09911bf2008-07-26 23:55:2965
[email protected]39008c02009-02-11 23:59:2566class SkBitmap;
[email protected]46f36a492010-07-28 19:36:4167
[email protected]180ef242013-11-07 06:50:4668namespace blink {
Antonio Gomes925f9b92019-07-30 23:23:2369class WebVideoCaptureImplManager;
[email protected]b7c7bcf2009-10-03 07:07:3470}
71
[email protected]64ffa0442011-10-03 22:08:3672namespace base {
skyostil457b0a12014-09-09 10:12:0773class SingleThreadTaskRunner;
[email protected]64ffa0442011-10-03 22:08:3674class Thread;
75}
76
[email protected]c29b7ff2013-03-06 03:51:0477namespace cc {
reveman34b7a1522015-03-23 20:27:4778class TaskGraphRunner;
[email protected]c29b7ff2013-03-06 03:51:0479}
80
penghuang346a46f92016-03-31 21:37:5281namespace gpu {
82class GpuChannelHost;
83}
84
[email protected]563d665f2013-02-01 04:42:3985namespace media {
[email protected]2329bfc72014-02-28 02:03:2186class GpuVideoAcceleratorFactories;
[email protected]563d665f2013-02-01 04:42:3987}
88
Ken Rockot13051c932019-11-14 20:11:5189namespace mojo {
90class BinderMap;
91}
92
danakj92429852017-06-29 00:19:0393namespace viz {
Scott Violet7e33efc2018-08-29 22:30:1594class ContextProviderCommandBuffer;
95class Gpu;
Scott Violet703b8242019-06-11 19:34:3696class RasterContextProvider;
97class SyntheticBeginFrameSource;
98} // namespace viz
Scott Violet7e33efc2018-08-29 22:30:1599
[email protected]64ffa0442011-10-03 22:08:36100namespace content {
[email protected]3958e972012-07-17 00:25:41101class AudioRendererMixerManager;
fsamuel6c1dfeb2014-12-18 19:21:33102class BrowserPluginManager;
John Abd-El-Maleke1d4de32017-10-21 16:14:29103class CategorizedWorkerPool;
John Abd-El-Maleke1d4de32017-10-21 16:14:29104class GpuVideoAcceleratorFactoriesImpl;
Robert Sesek6e3d725c2018-06-06 14:38:02105class LowMemoryModeController;
tyoshino832a58a2016-04-18 08:14:08106class RenderThreadObserver;
tfarina556a7232014-10-05 01:02:09107class RendererBlinkPlatformImpl;
John Abd-El-Malek6b56ef712017-10-21 22:52:46108class ResourceDispatcher;
[email protected]cb25aa12012-08-07 19:13:43109
boliubee541f42015-11-05 00:52:53110#if defined(OS_ANDROID)
siva.gunturi5d4feb052015-11-15 16:15:31111class StreamTextureFactory;
boliubee541f42015-11-05 00:52:53112#endif
113
jam8a021512a2015-02-03 18:16:08114#if defined(COMPILER_MSVC)
115// See explanation for other RenderViewHostImpl which is the same issue.
116#pragma warning(push)
117#pragma warning(disable: 4250)
118#endif
119
Matt Falkenhagenef13d782019-05-30 21:02:12120// The RenderThreadImpl class represents the main thread, where RenderView
initial.commit09911bf2008-07-26 23:55:29121// instances live. The RenderThread supports an API that is used by its
122// consumer to talk indirectly to the RenderViews and supporting objects.
123// Likewise, it provides an API for the RenderViews to talk back to the main
[email protected]770005b2012-04-16 15:58:13124// process (i.e., their corresponding WebContentsImpl).
initial.commit09911bf2008-07-26 23:55:29125//
126// Most of the communication occurs in the form of IPC messages. They are
127// routed to the RenderThread according to the routing IDs of the messages.
128// The routing IDs correspond to RenderView instances.
danakj6e3bf8012014-12-16 18:27:53129class CONTENT_EXPORT RenderThreadImpl
130 : public RenderThread,
jam8a021512a2015-02-03 18:16:08131 public ChildThreadImpl,
Nico Weber43ddd7a32017-08-15 19:19:27132 public mojom::Renderer,
danakjab9ef4d2017-10-31 23:38:33133 public viz::mojom::CompositingModeWatcher,
Nico Weber43ddd7a32017-08-15 19:19:27134 public CompositorDependencies {
initial.commit09911bf2008-07-26 23:55:29135 public:
[email protected]f1a29a02011-10-06 23:08:44136 static RenderThreadImpl* current();
rockot5c478a72016-09-28 23:14:18137 static mojom::RenderMessageFilter* current_render_message_filter();
olegmax045f7fb12017-05-19 07:58:55138 static RendererBlinkPlatformImpl* current_blink_platform_impl();
rockot5c478a72016-09-28 23:14:18139
140 static void SetRenderMessageFilterForTesting(
141 mojom::RenderMessageFilter* render_message_filter);
olegmax045f7fb12017-05-19 07:58:55142 static void SetRendererBlinkPlatformImplForTesting(
143 RendererBlinkPlatformImpl* blink_platform_impl);
[email protected]526476902011-10-06 20:34:06144
John Abd-El-Malekd4882642017-12-04 21:45:19145 // Returns the task runner for the main thread where the RenderThread lives.
Hajime Hoshi20578c62018-01-12 09:43:26146 static scoped_refptr<base::SingleThreadTaskRunner>
147 DeprecatedGetMainTaskRunner();
John Abd-El-Malekd4882642017-12-04 21:45:19148
Wez6979109b2018-09-07 17:30:56149 RenderThreadImpl(
150 base::RepeatingClosure quit_closure,
Greg Kraynovf5d60272018-08-10 12:28:51151 std::unique_ptr<blink::scheduler::WebThreadScheduler> scheduler);
152 RenderThreadImpl(
153 const InProcessChildThreadParams& params,
Sunny Sachanandanie3e582502019-10-22 20:10:38154 int32_t client_id,
Greg Kraynovf5d60272018-08-10 12:28:51155 std::unique_ptr<blink::scheduler::WebThreadScheduler> scheduler);
dcheng6d18e402014-10-21 12:32:52156 ~RenderThreadImpl() override;
157 void Shutdown() override;
harakenbbfdd9f02017-01-12 07:14:04158 bool ShouldBeDestroyed() override;
initial.commit09911bf2008-07-26 23:55:29159
[email protected]58436a12012-03-21 17:10:26160 // When initializing WebKit, ensure that any schemes needed for the content
161 // module are registered properly. Static to allow sharing with tests.
162 static void RegisterSchemes();
163
[email protected]e9ff79c2012-10-19 21:31:26164 // RenderThread implementation:
dcheng6d18e402014-10-21 12:32:52165 bool Send(IPC::Message* msg) override;
dcheng6d18e402014-10-21 12:32:52166 IPC::SyncChannel* GetChannel() override;
167 std::string GetLocale() override;
168 IPC::SyncMessageFilter* GetSyncMessageFilter() override;
avi1023d012015-12-25 02:39:14169 void AddRoute(int32_t routing_id, IPC::Listener* listener) override;
170 void RemoveRoute(int32_t routing_id) override;
dcheng6d18e402014-10-21 12:32:52171 int GenerateRoutingID() override;
172 void AddFilter(IPC::MessageFilter* filter) override;
173 void RemoveFilter(IPC::MessageFilter* filter) override;
tyoshino832a58a2016-04-18 08:14:08174 void AddObserver(RenderThreadObserver* observer) override;
175 void RemoveObserver(RenderThreadObserver* observer) override;
dcheng6d18e402014-10-21 12:32:52176 void SetResourceDispatcherDelegate(
mohan.reddyee0b42a2014-10-08 04:53:14177 ResourceDispatcherDelegate* delegate) override;
dchengcedca5612016-04-09 01:40:15178 std::unique_ptr<base::SharedMemory> HostAllocateSharedMemoryBuffer(
mohan.reddyee0b42a2014-10-08 04:53:14179 size_t buffer_size) override;
Clemens Hammacher38b6a762019-02-05 13:07:22180 void RegisterExtension(std::unique_ptr<v8::Extension> extension) override;
danakj8bda2712019-05-24 23:20:44181 int PostTaskToAllWebWorkers(const base::RepeatingClosure& closure) override;
dcheng6d18e402014-10-21 12:32:52182 bool ResolveProxy(const GURL& url, std::string* proxy_list) override;
183 base::WaitableEvent* GetShutdownEvent() override;
staraz067f58242016-11-07 21:06:41184 int32_t GetClientId() override;
Nasko Oskov3d0d1dc2018-09-25 03:57:13185 bool IsOnline() override;
Karan Bhatiac89897f2017-08-10 01:06:40186 void SetRendererProcessType(
Yuta Kitamura63593502018-11-12 09:27:13187 blink::scheduler::WebRendererProcessType type) override;
Lucas Furukawa Gadanid51ff5d62018-12-07 21:26:49188 blink::WebString GetUserAgent() override;
Mike West6e4cbb32019-02-13 09:40:17189 const blink::UserAgentMetadata& GetUserAgentMetadata() override;
[email protected]1223d6ef2011-03-28 16:47:50190
rockot067ca55f2016-09-30 22:00:15191 // IPC::Listener implementation via ChildThreadImpl:
192 void OnAssociatedInterfaceRequest(
193 const std::string& name,
194 mojo::ScopedInterfaceEndpointHandle handle) override;
195
weilifabbf7572017-05-22 19:05:16196 // ChildThread implementation via ChildThreadImpl:
197 scoped_refptr<base::SingleThreadTaskRunner> GetIOTaskRunner() override;
198
danakj6e3bf8012014-12-16 18:27:53199 // CompositorDependencies implementation.
danakj6e3bf8012014-12-16 18:27:53200 bool IsGpuRasterizationForced() override;
senorblancob60ba952015-01-27 19:12:36201 int GetGpuRasterizationMSAASampleCount() override;
danakj6e3bf8012014-12-16 18:27:53202 bool IsLcdTextEnabled() override;
danakj6e3bf8012014-12-16 18:27:53203 bool IsZeroCopyEnabled() override;
ericrk1d17f752015-10-20 03:03:07204 bool IsPartialRasterEnabled() override;
ccameronc7fcd132015-11-03 20:14:31205 bool IsGpuMemoryBufferCompositorResourcesEnabled() override;
ccamerona7644752014-12-30 01:16:31206 bool IsElasticOverscrollEnabled() override;
danakj4b347212018-07-04 17:55:17207 bool IsUseZoomForDSFEnabled() override;
danakj6e3bf8012014-12-16 18:27:53208 scoped_refptr<base::SingleThreadTaskRunner>
209 GetCompositorMainThreadTaskRunner() override;
210 scoped_refptr<base::SingleThreadTaskRunner>
211 GetCompositorImplThreadTaskRunner() override;
danakjf24dc812019-10-04 19:03:16212 scoped_refptr<base::SingleThreadTaskRunner> GetCleanupTaskRunner() override;
Yuta Kitamuradeb91bb2018-05-29 05:53:20213 blink::scheduler::WebThreadScheduler* GetWebMainThreadScheduler() override;
reveman34b7a1522015-03-23 20:27:47214 cc::TaskGraphRunner* GetTaskGraphRunner() override;
wjmaclean1d970622017-01-21 22:28:24215 bool IsScrollAnimatorEnabled() override;
Khushal3e96e662017-10-30 23:16:50216 std::unique_ptr<cc::UkmRecorderFactory> CreateUkmRecorderFactory() override;
danakj2d2889a2019-04-05 21:22:08217 void RequestNewLayerTreeFrameSink(
Erik Chen450ab562019-10-10 18:58:13218 RenderWidget* render_widget,
danakj2d2889a2019-04-05 21:22:08219 scoped_refptr<FrameSwapMessageQueue> frame_swap_message_queue,
220 const GURL& url,
221 LayerTreeFrameSinkCallback callback,
Julie Jeongeun Kim4421c2e2019-09-11 06:34:39222 mojo::PendingReceiver<mojom::RenderFrameMetadataObserverClient>
223 render_frame_metadata_observer_client_receiver,
Julie Jeongeun Kim6f4b7e02019-09-11 05:05:46224 mojo::PendingRemote<mojom::RenderFrameMetadataObserver>
225 render_frame_metadata_observer_remote,
danakj2d2889a2019-04-05 21:22:08226 const char* client_name) override;
danakj4b347212018-07-04 17:55:17227#ifdef OS_ANDROID
228 bool UsingSynchronousCompositing() override;
229#endif
danakj6e3bf8012014-12-16 18:27:53230
danakje6da4f12018-07-04 17:41:30231 bool IsThreadedAnimationEnabled();
232
danakjab9ef4d2017-10-31 23:38:33233 // viz::mojom::CompositingModeWatcher implementation.
234 void CompositingModeFallbackToSoftware() override;
235
236 // Whether gpu compositing is being used or is disabled for software
237 // compositing. Clients of the compositor should give resources that match
238 // the appropriate mode.
239 bool IsGpuCompositingDisabled() { return is_gpu_compositing_disabled_; }
240
[email protected]b3e83de2012-02-07 03:33:28241 // Synchronously establish a channel to the GPU plugin if not previously
242 // established or if it has been lost (for example if the GPU plugin crashed).
243 // If there is a pending asynchronous request, it will be completed by the
Bo Liud1ef1c32017-12-08 06:15:50244 // time this routine returns.
245 scoped_refptr<gpu::GpuChannelHost> EstablishGpuChannelSync();
[email protected]b3e83de2012-02-07 03:33:28246
pimanc44437a22016-10-29 00:09:22247 gpu::GpuMemoryBufferManager* GetGpuMemoryBufferManager();
248
Sam McNally52e50282017-11-29 00:54:02249 blink::AssociatedInterfaceRegistry* GetAssociatedInterfaceRegistry();
rockot067ca55f2016-09-30 22:00:15250
Kent Tamura2eab5b12018-12-07 04:31:23251 // True if we are running web tests. This currently disables forwarding
[email protected]70dee7e2013-05-29 18:28:30252 // various status messages to the console, skips network error pages, and
253 // short circuits size update and focus events.
danakjbecba322019-03-29 17:13:46254 bool web_test_mode() const { return web_test_mode_; }
255 void enable_web_test_mode() { web_test_mode_ = true; }
[email protected]ac7f5a02013-03-16 16:14:41256
Gordon Guan96c21ee2019-11-06 15:05:39257 base::DiscardableMemoryAllocator* GetDiscardableMemoryAllocatorForTest()
258 const {
259 return discardable_memory_allocator_.get();
penghuang342762b2016-12-02 21:04:58260 }
261
tfarina556a7232014-10-05 01:02:09262 RendererBlinkPlatformImpl* blink_platform_impl() const {
263 DCHECK(blink_platform_impl_);
264 return blink_platform_impl_.get();
[email protected]078780b2014-06-20 16:57:06265 }
266
Yuta Kitamura4e256bfc2018-09-27 06:32:35267 // Returns the task runner on the compositor thread.
268 //
danakj6e3bf8012014-12-16 18:27:53269 // Will be null if threaded compositing has not been enabled.
skyostil2d3b5bd2015-05-27 15:40:59270 scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner() const {
271 return compositor_task_runner_;
[email protected]a9fb30aa2011-10-06 06:58:46272 }
273
John Abd-El-Malek6b56ef712017-10-21 22:52:46274 ResourceDispatcher* resource_dispatcher() const {
275 return resource_dispatcher_.get();
276 }
277
Yuzhu Shenfe5f3a52018-01-11 21:24:13278 URLLoaderThrottleProvider* url_loader_throttle_provider() const {
279 return url_loader_throttle_provider_.get();
280 }
281
[email protected]6ca6a082013-09-22 20:10:05282#if defined(OS_ANDROID)
siva.gunturi5d4feb052015-11-15 16:15:31283 scoped_refptr<StreamTextureFactory> GetStreamTexureFactory();
boliuf8753bf62016-02-11 20:09:42284 bool EnableStreamTextureCopy();
[email protected]6ca6a082013-09-22 20:10:05285#endif
286
fsamuel6c1dfeb2014-12-18 19:21:33287 BrowserPluginManager* browser_plugin_manager() const {
288 return browser_plugin_manager_.get();
289 }
290
Antonio Gomes925f9b92019-07-30 23:23:23291 blink::WebVideoCaptureImplManager* video_capture_impl_manager() const {
[email protected]80b161a2011-06-27 17:42:11292 return vc_manager_.get();
293 }
294
Robert Sesek6e3d725c2018-06-06 14:38:02295 LowMemoryModeController* low_memory_mode_controller() const {
296 return low_memory_mode_controller_.get();
297 }
298
rockote261d2112016-09-21 22:22:23299 mojom::RenderMessageFilter* render_message_filter();
rockot1587e332016-07-27 17:44:14300
[email protected]6217d392010-03-25 22:08:35301 // Get the GPU channel. Returns NULL if the channel is not established or
302 // has been lost.
penghuang346a46f92016-03-31 21:37:52303 gpu::GpuChannelHost* GetGpuChannel();
[email protected]6217d392010-03-25 22:08:35304
skyostil2d3b5bd2015-05-27 15:40:59305 // Returns a SingleThreadTaskRunner instance corresponding to the message loop
[email protected]c1330c82013-06-06 02:23:25306 // of the thread on which media operations should be run. Must be called
307 // on the renderer's main thread.
acolwellb4034942014-08-28 15:42:43308 scoped_refptr<base::SingleThreadTaskRunner> GetMediaThreadTaskRunner();
[email protected]c1330c82013-06-06 02:23:25309
dcastagna4517a182015-08-05 19:51:03310 // A TaskRunner instance that runs tasks on the raster worker pool.
311 base::TaskRunner* GetWorkerTaskRunner();
dcastagnab880e8f2015-06-30 20:16:06312
CJ DiMeglio79f7c91a22018-08-30 22:24:43313 // Creates a ContextProvider if yet created, and returns it to be used for
314 // video frame compositing. The ContextProvider given as an argument is
315 // one that has been lost, and is a hint to the RenderThreadImpl to clear
316 // it's |video_frame_compositor_context_provider_| if it matches.
Sergey Ulanov83f4a152019-02-14 03:54:25317 scoped_refptr<viz::RasterContextProvider>
318 GetVideoFrameCompositorContextProvider(
319 scoped_refptr<viz::RasterContextProvider>);
CJ DiMeglio79f7c91a22018-08-30 22:24:43320
danakj0b4b94e32016-05-10 22:33:01321 // Returns a worker context provider that will be bound on the compositor
322 // thread.
Victor Miuraff6488612017-12-21 04:16:15323 scoped_refptr<viz::RasterContextProvider>
Jonathan Backer8e4f35d2018-10-15 20:56:42324 SharedCompositorWorkerContextProvider(bool try_gpu_rasterization);
revemand180dfc32015-09-24 00:19:43325
dcastagna7f45dada2015-10-19 20:17:35326 media::GpuVideoAcceleratorFactories* GetGpuFactories();
[email protected]3bb8bb32013-07-11 13:13:03327
Scott Violet703b8242019-06-11 19:34:36328 scoped_refptr<viz::ContextProviderCommandBuffer>
sadrul85cc5d82016-12-20 03:37:41329 SharedMainThreadContextProvider();
[email protected]c29b7ff2013-03-06 03:51:04330
[email protected]3958e972012-07-17 00:25:41331 // AudioRendererMixerManager instance which manages renderer side mixer
332 // instances shared based on configured audio parameters. Lazily created on
333 // first call.
[email protected]e9ff79c2012-10-19 21:31:26334 AudioRendererMixerManager* GetAudioRendererMixerManager();
[email protected]3958e972012-07-17 00:25:41335
Yuzu Saijo9acd7e62019-06-12 10:05:31336 class UnfreezableMessageFilter : public IPC::MessageFilter {
337 public:
338 explicit UnfreezableMessageFilter(RenderThreadImpl* render_thread_impl);
339 bool OnMessageReceived(const IPC::Message& message) override;
340
341 // Adds |unfreezable_task_runner| for the task to be executed later.
342 void AddListenerUnfreezableTaskRunner(
343 int32_t routing_id,
344 scoped_refptr<base::SingleThreadTaskRunner> unfreezable_task_runner);
345
346 // Called on the I/O thread.
347 // Returns the unfreezable task runner associated with |routing_id|.
348 scoped_refptr<base::SingleThreadTaskRunner> GetUnfreezableTaskRunner(
349 int32_t routing_id);
350
351 private:
352 ~UnfreezableMessageFilter() override;
353 RenderThreadImpl* render_thread_impl_;
354 base::Lock unfreezable_task_runners_lock_;
355 // Map of routing_id and listener's thread unfreezable task runner.
356 std::map<int32_t, scoped_refptr<base::SingleThreadTaskRunner>>
357 unfreezable_task_runners_ GUARDED_BY(unfreezable_task_runners_lock_);
358 };
359
[email protected]b2d98762012-09-03 17:04:06360 // For producing custom V8 histograms. Custom histograms are produced if all
361 // RenderViews share the same host, and the host is in the pre-specified set
362 // of hosts we want to produce custom diagrams for. The name for a custom
363 // diagram is the name of the corresponding generic diagram plus a
364 // host-specific suffix.
365 class CONTENT_EXPORT HistogramCustomizer {
366 public:
367 HistogramCustomizer();
368 ~HistogramCustomizer();
369
370 // Called when a top frame of a RenderView navigates. This function updates
371 // RenderThreadImpl's information about whether all RenderViews are
372 // displaying a page from the same host. |host| is the host where a
373 // RenderView navigated, and |view_count| is the number of RenderViews in
374 // this process.
375 void RenderViewNavigatedToHost(const std::string& host, size_t view_count);
376
377 // Used for customizing some histograms if all RenderViews share the same
378 // host. Returns the current custom histogram name to use for
379 // |histogram_name|, or |histogram_name| if it shouldn't be customized.
380 std::string ConvertToCustomHistogramName(const char* histogram_name) const;
381
382 private:
hablichd6a4f122015-10-28 11:34:49383 FRIEND_TEST_ALL_PREFIXES(RenderThreadImplUnittest,
384 IdentifyAlexaTop10NonGoogleSite);
[email protected]b2d98762012-09-03 17:04:06385 friend class RenderThreadImplUnittest;
Yuzu Saijo9acd7e62019-06-12 10:05:31386 friend class UnfreezableMessageFilter;
[email protected]b2d98762012-09-03 17:04:06387
hablichd6a4f122015-10-28 11:34:49388 // Converts a host name to a suffix for histograms
389 std::string HostToCustomHistogramSuffix(const std::string& host);
390
391 // Helper function to identify a certain set of top pages
392 bool IsAlexaTop10NonGoogleSite(const std::string& host);
393
[email protected]b2d98762012-09-03 17:04:06394 // Used for updating the information on which is the common host which all
395 // RenderView's share (if any). If there is no common host, this function is
396 // called with an empty string.
397 void SetCommonHost(const std::string& host);
398
399 // The current common host of the RenderViews; empty string if there is no
400 // common host.
401 std::string common_host_;
402 // The corresponding suffix.
403 std::string common_host_histogram_suffix_;
404 // Set of histograms for which we want to produce a custom histogram if
405 // possible.
406 std::set<std::string> custom_histograms_;
407
408 DISALLOW_COPY_AND_ASSIGN(HistogramCustomizer);
409 };
410
411 HistogramCustomizer* histogram_customizer() {
412 return &histogram_customizer_;
413 }
414
benf28ce882017-05-02 16:15:49415 void RegisterPendingFrameCreate(
benf28ce882017-05-02 16:15:49416 int routing_id,
Henrique Ferreiro3a9751c2019-09-30 13:54:07417 mojo::PendingReceiver<mojom::Frame> frame);
rockotf8fdd9b2015-12-16 22:22:35418
jam188f19f2017-06-07 03:56:24419 mojom::RendererHost* GetRendererHost();
jamc912ca32016-02-24 20:17:31420
keishi51ed0d52017-01-12 10:04:46421 struct RendererMemoryMetrics {
422 size_t partition_alloc_kb;
423 size_t blink_gc_kb;
424 size_t malloc_mb;
425 size_t discardable_kb;
426 size_t v8_main_thread_isolate_mb;
427 size_t total_allocated_mb;
428 size_t non_discardable_total_allocated_mb;
429 size_t total_allocated_per_render_view_mb;
430 };
bashia0ba0d42017-04-03 08:11:06431 bool GetRendererMemoryMetrics(RendererMemoryMetrics* memory_metrics) const;
keishi51ed0d52017-01-12 10:04:46432
Takashi SAKAMOTO870f6262017-08-22 04:08:27433 bool NeedsToRecordFirstActivePaint(int metric_type) const;
tasakb95dbb50c2017-02-08 18:07:50434
Aditya Keerthie84331b32019-03-20 15:25:52435 void RecordMetricsForBackgroundedRendererPurge();
436
Miguel Casas5e1018052018-01-09 19:17:36437 // Sets the current pipeline rendering color space.
438 void SetRenderingColorSpace(const gfx::ColorSpace& color_space);
439
CJ DiMeglio79f7c91a22018-08-30 22:24:43440 scoped_refptr<base::SingleThreadTaskRunner>
441 CreateVideoFrameCompositorTaskRunner();
442
CJ DiMegliob6eb9cd2018-11-06 23:44:01443 // In the case of kOnDemand, we wont be using the task_runner created in
444 // CreateVideoFrameCompositorTaskRunner.
445 // TODO(https://crbug/901513): Remove once kOnDemand is removed.
446 void SetVideoFrameCompositorTaskRunner(
447 scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
448 video_frame_compositor_task_runner_ = task_runner;
449 }
450
[email protected]8930d472009-02-21 08:05:28451 private:
Aditya Keerthic0d45b42019-02-25 18:53:00452 friend class RenderThreadImplBrowserTest;
453
Nicholas Verne06de8122017-11-16 04:47:38454 void OnProcessFinalRelease() override;
torne88b66452016-05-03 13:22:14455 // IPC::Listener
456 void OnChannelError() override;
457
[email protected]57cf97882013-06-26 20:39:01458 // ChildThread
dcheng6d18e402014-10-21 12:32:52459 bool OnControlMessageReceived(const IPC::Message& msg) override;
liberato3aeeb2c2016-02-25 17:54:38460 void RecordAction(const base::UserMetricsAction& action) override;
461 void RecordComputedAction(const std::string& action) override;
initial.commit09911bf2008-07-26 23:55:29462
sadrul53546592016-12-17 01:44:21463 bool IsMainThread();
[email protected]57cf97882013-06-26 20:39:01464
bashib9058f282017-03-30 01:55:24465 void RecordPurgeMemory(RendererMemoryMetrics before);
466
Greg Kraynovf5d60272018-08-10 12:28:51467 void Init();
vollick1050cc62015-12-03 07:04:54468 void InitializeCompositorThread();
Ken Rockot13051c932019-11-14 20:11:51469 void InitializeWebKit(mojo::BinderMap* binders);
jam75c44222016-03-23 05:34:24470
initial.commit09911bf2008-07-26 23:55:29471 void OnTransferBitmap(const SkBitmap& bitmap, int resource_id);
[email protected]b3df5a42010-05-11 14:31:09472 void OnGetAccessibilityTree();
blundellc00adf442016-09-16 10:43:41473
rockot067ca55f2016-09-30 22:00:15474 // mojom::Renderer:
rockot067ca55f2016-09-30 22:00:15475 void CreateView(mojom::CreateViewParamsPtr params) override;
Erik Chen3433ee02019-08-05 20:14:26476 void DestroyView(int32_t view_id) override;
rockot53be7caf2016-10-04 20:17:08477 void CreateFrame(mojom::CreateFrameParamsPtr params) override;
Dmitry Gozman89361212018-02-13 16:10:44478 void CreateFrameProxy(
479 int32_t routing_id,
480 int32_t render_view_routing_id,
481 int32_t opener_routing_id,
482 int32_t parent_routing_id,
483 const FrameReplicationState& replicated_state,
484 const base::UnguessableToken& devtools_frame_token) override;
rockota2db0da2016-10-18 17:39:11485 void OnNetworkConnectionChanged(
486 net::NetworkChangeNotifier::ConnectionType type,
487 double max_bandwidth_mbps) override;
tbansalb612c5d2017-05-25 18:53:06488 void OnNetworkQualityChanged(net::EffectiveConnectionType type,
489 base::TimeDelta http_rtt,
tbansal99d8aeb2017-05-22 19:12:58490 base::TimeDelta transport_rtt,
tbansal15973c32017-05-10 18:40:44491 double bandwidth_kbps) override;
rockota2db0da2016-10-18 17:39:11492 void SetWebKitSharedTimersSuspended(bool suspend) override;
Yutaka Hiranob0465f72018-05-17 05:48:25493 void SetUserAgent(const std::string& user_agent) override;
Mike West6e4cbb32019-02-13 09:40:17494 void SetUserAgentMetadata(const blink::UserAgentMetadata& metadata) override;
rockota2db0da2016-10-18 17:39:11495 void UpdateScrollbarTheme(
496 mojom::UpdateScrollbarThemeParamsPtr params) override;
497 void OnSystemColorsChanged(int32_t aqua_color_variant,
498 const std::string& highlight_text_color,
499 const std::string& highlight_color) override;
Ionel Popescu237e8e32019-08-07 19:50:54500 void UpdateSystemColorInfo(
501 mojom::UpdateSystemColorInfoParamsPtr params) override;
rockota2db0da2016-10-18 17:39:11502 void PurgePluginListCache(bool reload_pages) override;
John Budorickee1c9512019-10-17 15:32:19503 void SetProcessState(mojom::RenderProcessBackgroundState background_state,
504 mojom::RenderProcessVisibleState visible_state) override;
Shubhie Panicker45ce80a82018-02-01 01:40:19505 void SetSchedulerKeepActive(bool keep_active) override;
Nasko Oskov1c2c0492019-03-14 20:13:39506 void SetIsLockedToSite() override;
Robert Sesek6e3d725c2018-06-06 14:38:02507 void EnableV8LowMemoryMode() override;
rockot067ca55f2016-09-30 22:00:15508
[email protected]5071cb22013-07-10 02:19:06509 void OnMemoryPressure(
510 base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level);
rockota2db0da2016-10-18 17:39:11511
rmcilroyaa296052015-04-14 15:35:27512 bool RendererIsHidden() const;
513 void OnRendererHidden();
514 void OnRendererVisible();
[email protected]b3df5a42010-05-11 14:31:09515
Aditya Keerthic0d45b42019-02-25 18:53:00516 bool RendererIsBackgrounded() const;
517 void OnRendererBackgrounded();
518 void OnRendererForegrounded();
519
tasak335a1872017-06-14 09:50:23520 void RecordMemoryUsageAfterBackgrounded(const char* suffix,
521 int foregrounded_count);
Aditya Keerthie84331b32019-03-20 15:25:52522 void OnRecordMetricsForBackgroundedRendererPurgeTimerExpired(
tasakbb0640b2017-05-15 09:02:26523 const char* suffix,
524 int foregrounded_count_when_purged);
tasakb46626a2016-10-18 05:54:44525
ssid0603ca9f2015-06-09 16:48:08526 void ReleaseFreeMemory();
527
hong.zhengb28b5332016-05-11 02:33:39528 void OnSyncMemoryPressure(
529 base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level);
530
Fady Samuelc645ffe2017-07-24 17:28:20531 std::unique_ptr<viz::SyntheticBeginFrameSource>
samans09812d32017-03-27 19:51:50532 CreateSyntheticBeginFrameSource();
533
Julie Jeongeun Kim4e77af2622019-09-11 03:36:45534 void OnRendererInterfaceReceiver(
535 mojo::PendingAssociatedReceiver<mojom::Renderer> receiver);
rockot067ca55f2016-09-30 22:00:15536
Gordon Guan96c21ee2019-11-06 15:05:39537 std::unique_ptr<base::DiscardableMemoryAllocator>
538 discardable_memory_allocator_;
penghuang342762b2016-12-02 21:04:58539
initial.commit09911bf2008-07-26 23:55:29540 // These objects live solely on the render thread.
Yuta Kitamuradeb91bb2018-05-29 05:53:20541 std::unique_ptr<blink::scheduler::WebThreadScheduler> main_thread_scheduler_;
dchengcedca5612016-04-09 01:40:15542 std::unique_ptr<RendererBlinkPlatformImpl> blink_platform_impl_;
John Abd-El-Malek6b56ef712017-10-21 22:52:46543 std::unique_ptr<ResourceDispatcher> resource_dispatcher_;
Yuzhu Shenfe5f3a52018-01-11 21:24:13544 std::unique_ptr<URLLoaderThrottleProvider> url_loader_throttle_provider_;
[email protected]9291ed12009-07-23 17:33:22545
dchengcedca5612016-04-09 01:40:15546 std::unique_ptr<BrowserPluginManager> browser_plugin_manager_;
fsamuel6c1dfeb2014-12-18 19:21:33547
Yuzu Saijo9acd7e62019-06-12 10:05:31548 // Filter out unfreezable messages and pass it to unfreezable task runners.
549 scoped_refptr<UnfreezableMessageFilter> unfreezable_message_filter_;
550
Max Morin3d464a42018-01-15 11:17:00551 // Provides AudioInputIPC objects for audio input devices. Initialized in
552 // Init.
553 base::Optional<AudioInputIPCFactory> audio_input_ipc_factory_;
Max Morin2c38c282018-04-17 07:01:42554 // Provides AudioOutputIPC objects for audio output devices. Initialized in
555 // Init.
Max Morin3d464a42018-01-15 11:17:00556 base::Optional<AudioOutputIPCFactory> audio_output_ipc_factory_;
maxmorin017ba8c62017-06-02 10:23:09557
liushouqun517b1292016-09-14 05:58:59558 // Used on the render thread.
Antonio Gomes925f9b92019-07-30 23:23:23559 std::unique_ptr<blink::WebVideoCaptureImplManager> vc_manager_;
[email protected]da9f30a2014-06-18 19:39:04560
Aditya Keerthic0d45b42019-02-25 18:53:00561 // Used to keep track of the renderer's backgrounded and visibility state.
562 // Updated via an IPC from the browser process. If nullopt, the browser
563 // process has yet to send an update and the state is unknown.
John Budorickee1c9512019-10-17 15:32:19564 base::Optional<mojom::RenderProcessBackgroundState> background_state_;
565 base::Optional<mojom::RenderProcessVisibleState> visible_state_;
[email protected]bee16aab2009-08-26 15:55:03566
Yutaka Hiranob0465f72018-05-17 05:48:25567 blink::WebString user_agent_;
Mike West6e4cbb32019-02-13 09:40:17568 blink::UserAgentMetadata user_agent_metadata_;
Yutaka Hiranob0465f72018-05-17 05:48:25569
Kent Tamura2eab5b12018-12-07 04:31:23570 // Used to control web test specific behavior.
danakjbecba322019-03-29 17:13:46571 bool web_test_mode_ = false;
[email protected]233567d2013-02-27 20:22:02572
danakjab9ef4d2017-10-31 23:38:33573 // Sticky once true, indicates that compositing is done without Gpu, so
574 // resources given to the compositor or to the viz service should be
575 // software-based.
576 bool is_gpu_compositing_disabled_ = false;
577
dcastagna7f45dada2015-10-19 20:17:35578 // Utility class to provide GPU functionalities to media.
dcastagna09bd6b32016-02-01 21:54:28579 // TODO(dcastagna): This should be just one scoped_ptr once
580 // http://crbug.com/580386 is fixed.
581 // NOTE(dcastagna): At worst this accumulates a few bytes per context lost.
Miguel Casas-Sanchezcfcca5d52017-07-07 02:32:59582 std::vector<std::unique_ptr<GpuVideoAcceleratorFactoriesImpl>> gpu_factories_;
dcastagna7f45dada2015-10-19 20:17:35583
[email protected]c1330c82013-06-06 02:23:25584 // Thread for running multimedia operations (e.g., video decoding).
dchengcedca5612016-04-09 01:40:15585 std::unique_ptr<base::Thread> media_thread_;
[email protected]c1330c82013-06-06 02:23:25586
skyostil2d3b5bd2015-05-27 15:40:59587 // Will point to appropriate task runner after initialization,
[email protected]ea5f70a2013-03-07 12:30:36588 // regardless of whether |compositor_thread_| is overriden.
skyostil2d3b5bd2015-05-27 15:40:59589 scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner_;
[email protected]ea5f70a2013-03-07 12:30:36590
CJ DiMeglio79f7c91a22018-08-30 22:24:43591 // Task to run the VideoFrameCompositor on.
592 scoped_refptr<base::SingleThreadTaskRunner>
593 video_frame_compositor_task_runner_;
594
dcastagnab880e8f2015-06-30 20:16:06595 // Pool of workers used for raster operations (e.g., tile rasterization).
prashant.nfad657e2016-06-01 07:52:17596 scoped_refptr<CategorizedWorkerPool> categorized_worker_pool_;
reveman34b7a1522015-03-23 20:27:47597
boliubee541f42015-11-05 00:52:53598#if defined(OS_ANDROID)
siva.gunturi5d4feb052015-11-15 16:15:31599 scoped_refptr<StreamTextureFactory> stream_texture_factory_;
boliubee541f42015-11-05 00:52:53600#endif
601
Scott Violet703b8242019-06-11 19:34:36602 scoped_refptr<viz::ContextProviderCommandBuffer> shared_main_thread_contexts_;
[email protected]c29b7ff2013-03-06 03:51:04603
Trent Apteda250ec3ab2018-08-19 08:52:19604 base::ObserverList<RenderThreadObserver>::Unchecked observers_;
[email protected]1223d6ef2011-03-28 16:47:50605
Sergey Ulanov83f4a152019-02-14 03:54:25606 scoped_refptr<viz::RasterContextProvider>
607 video_frame_compositor_context_provider_;
CJ DiMeglio79f7c91a22018-08-30 22:24:43608
Victor Miuraff6488612017-12-21 04:16:15609 scoped_refptr<viz::RasterContextProvider> shared_worker_context_provider_;
[email protected]3b2afc32012-06-18 21:31:16610
dchengcedca5612016-04-09 01:40:15611 std::unique_ptr<AudioRendererMixerManager> audio_renderer_mixer_manager_;
[email protected]3958e972012-07-17 00:25:41612
[email protected]b2d98762012-09-03 17:04:06613 HistogramCustomizer histogram_customizer_;
614
dchengcedca5612016-04-09 01:40:15615 std::unique_ptr<base::MemoryPressureListener> memory_pressure_listener_;
[email protected]5071cb22013-07-10 02:19:06616
Robert Sesek6e3d725c2018-06-06 14:38:02617 // Created in response to EnableV8LowMemoryMode(), this manages V8's
618 // memory saving mode.
619 std::unique_ptr<LowMemoryModeController> low_memory_mode_controller_;
620
Scott Violet703b8242019-06-11 19:34:36621 std::unique_ptr<viz::Gpu> gpu_;
sadrul9e0bb1d2016-08-04 20:18:39622
skyostil457b0a12014-09-09 10:12:07623 scoped_refptr<base::SingleThreadTaskRunner>
624 main_thread_compositor_task_runner_;
skyostil457b0a12014-09-09 10:12:07625
danakj6e3bf8012014-12-16 18:27:53626 // Compositor settings.
[email protected]a23530d2014-03-11 06:04:14627 bool is_gpu_rasterization_forced_;
senorblancob60ba952015-01-27 19:12:36628 int gpu_rasterization_msaa_sample_count_;
[email protected]a23530d2014-03-11 06:04:14629 bool is_lcd_text_enabled_;
[email protected]2cccfef2014-05-01 06:05:16630 bool is_zero_copy_enabled_;
ccameronc7fcd132015-11-03 20:14:31631 bool is_gpu_memory_buffer_compositor_resources_enabled_;
ericrk1d17f752015-10-20 03:03:07632 bool is_partial_raster_enabled_;
ccamerona7644752014-12-30 01:16:31633 bool is_elastic_overscroll_enabled_;
danakj4b347212018-07-04 17:55:17634 bool is_zoom_for_dsf_enabled_;
loyso65c93c602015-08-11 05:15:57635 bool is_threaded_animation_enabled_;
wjmaclean1d970622017-01-21 22:28:24636 bool is_scroll_animator_enabled_;
[email protected]a23530d2014-03-11 06:04:14637
Miguel Casas5e1018052018-01-09 19:17:36638 // Target rendering ColorSpace.
639 gfx::ColorSpace rendering_color_space_;
640
ben76f52b242016-06-18 05:42:48641 class PendingFrameCreate : public base::RefCounted<PendingFrameCreate> {
rockotf8fdd9b2015-12-16 22:22:35642 public:
Ken Rockot13051c932019-11-14 20:11:51643 PendingFrameCreate(int routing_id,
Henrique Ferreiro3a9751c2019-09-30 13:54:07644 mojo::PendingReceiver<mojom::Frame> frame_receiver);
rockotf8fdd9b2015-12-16 22:22:35645
Henrique Ferreiro3a9751c2019-09-30 13:54:07646 mojo::PendingReceiver<mojom::Frame> TakeFrameReceiver() {
647 return std::move(frame_receiver_);
648 }
rockotf8fdd9b2015-12-16 22:22:35649
650 private:
ben76f52b242016-06-18 05:42:48651 friend class base::RefCounted<PendingFrameCreate>;
rockotf8fdd9b2015-12-16 22:22:35652
ben76f52b242016-06-18 05:42:48653 ~PendingFrameCreate();
rockotf8fdd9b2015-12-16 22:22:35654
655 // Mojo error handler.
656 void OnConnectionError();
657
rockotf8fdd9b2015-12-16 22:22:35658 int routing_id_;
Henrique Ferreiro3a9751c2019-09-30 13:54:07659 mojo::PendingReceiver<mojom::Frame> frame_receiver_;
rockotf8fdd9b2015-12-16 22:22:35660 };
661
ben76f52b242016-06-18 05:42:48662 using PendingFrameCreateMap =
663 std::map<int, scoped_refptr<PendingFrameCreate>>;
664 PendingFrameCreateMap pending_frame_creates_;
rockotf8fdd9b2015-12-16 22:22:35665
Julie Jeongeun Kimdaa9aa12019-10-24 02:51:56666 mojo::AssociatedRemote<mojom::RendererHost> renderer_host_;
jamc912ca32016-02-24 20:17:31667
Ken Rockot26e4e802018-07-31 15:03:33668 blink::AssociatedInterfaceRegistry associated_interfaces_;
rockot067ca55f2016-09-30 22:00:15669
Julie Jeongeun Kim4e77af2622019-09-11 03:36:45670 mojo::AssociatedReceiver<mojom::Renderer> renderer_receiver_{this};
rockot067ca55f2016-09-30 22:00:15671
Julie Jeongeun Kim23966e22019-10-26 02:13:29672 mojo::AssociatedRemote<mojom::RenderMessageFilter> render_message_filter_;
rockot1587e332016-07-27 17:44:14673
tasak72f64042017-01-19 14:02:53674 RendererMemoryMetrics purge_and_suspend_memory_metrics_;
tasakb95dbb50c2017-02-08 18:07:50675 bool needs_to_record_first_active_paint_;
Takashi SAKAMOTO870f6262017-08-22 04:08:27676 base::TimeTicks was_backgrounded_time_;
tasakbb0640b2017-05-15 09:02:26677 int process_foregrounded_count_;
Nasko Oskov3d0d1dc2018-09-25 03:57:13678 bool online_status_ = true;
hajimehoshi69093272016-05-13 08:30:58679
staraz067f58242016-11-07 21:06:41680 int32_t client_id_;
681
Mario Sanchez Prada5492c9a2019-09-10 20:58:11682 mojo::Remote<mojom::FrameSinkProvider> frame_sink_provider_;
samans2040988b2017-04-11 23:58:35683
danakjab9ef4d2017-10-31 23:38:33684 // A mojo connection to the CompositingModeReporter service.
Gyuyoung Kimc9cf74a2019-11-05 00:54:35685 mojo::Remote<viz::mojom::CompositingModeReporter> compositing_mode_reporter_;
danakjab9ef4d2017-10-31 23:38:33686 // The class is a CompositingModeWatcher, which is bound to mojo through
danakj4ee301c2017-11-29 16:19:43687 // this member.
Gyuyoung Kimef648a2e72019-09-17 09:48:35688 mojo::Receiver<viz::mojom::CompositingModeWatcher>
689 compositing_mode_watcher_receiver_{this};
danakjab9ef4d2017-10-31 23:38:33690
Jeremy Roman3bca4bf2019-07-11 03:41:25691 base::WeakPtrFactory<RenderThreadImpl> weak_factory_{this};
Ben Goodgerf180ce12018-02-09 22:54:01692
[email protected]f1a29a02011-10-06 23:08:44693 DISALLOW_COPY_AND_ASSIGN(RenderThreadImpl);
initial.commit09911bf2008-07-26 23:55:29694};
695
jam8a021512a2015-02-03 18:16:08696#if defined(COMPILER_MSVC)
697#pragma warning(pop)
698#endif
699
[email protected]e9ff79c2012-10-19 21:31:26700} // namespace content
701
[email protected]f1a29a02011-10-06 23:08:44702#endif // CONTENT_RENDERER_RENDER_THREAD_IMPL_H_