blob: 8cdd01be48654b55595759d29289437cab9eb5ef [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"
[email protected]5071cb22013-07-10 02:19:0620#include "base/memory/memory_pressure_listener.h"
rockot775ce0d2015-01-27 18:35:0121#include "base/memory/ref_counted.h"
[email protected]e6e30ac2014-01-13 21:24:3922#include "base/metrics/user_metrics_action.h"
[email protected]1223d6ef2011-03-28 16:47:5023#include "base/observer_list.h"
maxmorin017ba8c62017-06-02 10:23:0924#include "base/optional.h"
[email protected]21aa99682013-06-11 07:17:0125#include "base/strings/string16.h"
[email protected]88105162013-12-05 01:02:1226#include "base/threading/thread_checker.h"
tbansal99d8aeb2017-05-22 19:12:5827#include "base/time/time.h"
[email protected]abb522162013-06-28 01:54:1628#include "base/timer/timer.h"
[email protected]037fce02009-01-22 01:42:1529#include "build/build_config.h"
jam8a021512a2015-02-03 18:16:0830#include "content/child/child_thread_impl.h"
[email protected]8d128d62011-09-13 22:11:5731#include "content/common/content_export.h"
ben76f52b242016-06-18 05:42:4832#include "content/common/frame.mojom.h"
alexmosbc7eafa2014-12-06 01:38:0933#include "content/common/frame_replication_state.h"
samans2040988b2017-04-11 23:58:3534#include "content/common/frame_sink_provider.mojom.h"
rockot1587e332016-07-27 17:44:1435#include "content/common/render_frame_message_filter.mojom.h"
jonrossa2ff4f82018-02-16 17:27:4636#include "content/common/render_frame_metadata.mojom.h"
rockote261d2112016-09-21 22:22:2337#include "content/common/render_message_filter.mojom.h"
rockot067ca55f2016-09-30 22:00:1538#include "content/common/renderer.mojom.h"
jam188f19f2017-06-07 03:56:2439#include "content/common/renderer_host.mojom.h"
[email protected]526476902011-10-06 20:34:0640#include "content/public/renderer/render_thread.h"
Yuzhu Shenfe5f3a52018-01-11 21:24:1341#include "content/public/renderer/url_loader_throttle_provider.h"
danakj6e3bf8012014-12-16 18:27:5342#include "content/renderer/gpu/compositor_dependencies.h"
Amos Limbcc710e2018-06-08 05:51:1743#include "content/renderer/media/audio/audio_input_ipc_factory.h"
44#include "content/renderer/media/audio/audio_output_ipc_factory.h"
Kent Tamura2eab5b12018-12-07 04:31:2345#include "content/renderer/web_test_dependencies.h"
penghuang346a46f92016-03-31 21:37:5246#include "gpu/ipc/client/gpu_channel_host.h"
Antoine Laboure55c9ef82017-11-10 18:51:2347#include "ipc/ipc_sync_channel.h"
Scott Violeta35f9a42018-03-22 22:00:4448#include "media/media_buildflags.h"
rockot067ca55f2016-09-30 22:00:1549#include "mojo/public/cpp/bindings/associated_binding.h"
blundellc00adf442016-09-16 10:43:4150#include "mojo/public/cpp/bindings/binding.h"
jcivelli315d17f2016-11-29 16:15:0551#include "mojo/public/cpp/bindings/thread_safe_interface_ptr.h"
[email protected]d7ff5fb2014-05-29 19:50:2552#include "net/base/network_change_notifier.h"
tbansalb612c5d2017-05-25 18:53:0653#include "net/nqe/effective_connection_type.h"
Ken Rockot54311e62018-02-10 19:01:5254#include "services/network/public/mojom/url_loader_factory.mojom.h"
Ben Goodger21ada1e2017-07-19 14:53:0155#include "services/service_manager/public/cpp/bind_source_info.h"
Ken Rockot510c5972017-12-05 16:37:0456#include "services/service_manager/public/cpp/binder_registry.h"
danakjab9ef4d2017-10-31 23:38:3357#include "services/viz/public/interfaces/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"
Marijn Kruisselbrink4712c332018-06-13 19:06:5959#include "third_party/blink/public/mojom/dom_storage/storage_partition_service.mojom.h"
Kent Tamura38fb4342018-07-25 12:47:5360#include "third_party/blink/public/platform/scheduler/web_rail_mode_observer.h"
Blink Reformata30d4232018-04-07 15:31:0661#include "third_party/blink/public/platform/web_connection_type.h"
62#include "third_party/blink/public/web/web_memory_statistics.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)
Blink Reformata30d4232018-04-07 15:31:0666#include "third_party/blink/public/platform/mac/web_scrollbar_theme.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 {
[email protected]d8cd8372012-03-09 10:49:5172class WebMediaStreamCenter;
[email protected]b7c7bcf2009-10-03 07:07:3473}
74
[email protected]64ffa0442011-10-03 22:08:3675namespace base {
skyostil457b0a12014-09-09 10:12:0776class SingleThreadTaskRunner;
[email protected]64ffa0442011-10-03 22:08:3677class Thread;
78}
79
[email protected]c29b7ff2013-03-06 03:51:0480namespace cc {
jbrianceed975022016-11-04 09:14:2581class BeginFrameSource;
danakjc7afae52017-06-20 21:12:4182class LayerTreeFrameSink;
samans09812d32017-03-27 19:51:5083class SyntheticBeginFrameSource;
reveman34b7a1522015-03-23 20:27:4784class TaskGraphRunner;
[email protected]c29b7ff2013-03-06 03:51:0485}
86
penghuang342762b2016-12-02 21:04:5887namespace discardable_memory {
88class ClientDiscardableSharedMemoryManager;
89}
90
penghuang346a46f92016-03-31 21:37:5291namespace gpu {
92class GpuChannelHost;
93}
94
[email protected]1842fe22012-08-13 23:24:3595namespace IPC {
[email protected]74122042014-04-25 00:07:3096class MessageFilter;
[email protected]1842fe22012-08-13 23:24:3597}
98
[email protected]563d665f2013-02-01 04:42:3999namespace media {
[email protected]2329bfc72014-02-28 02:03:21100class GpuVideoAcceleratorFactories;
[email protected]563d665f2013-02-01 04:42:39101}
102
[email protected]e9ff79c2012-10-19 21:31:26103namespace v8 {
104class Extension;
105}
106
danakj92429852017-06-29 00:19:03107namespace viz {
Fady Samuelc645ffe2017-07-24 17:28:20108class BeginFrameSource;
Victor Miuraff6488612017-12-21 04:16:15109class RasterContextProvider;
Fady Samuelc645ffe2017-07-24 17:28:20110class SyntheticBeginFrameSource;
danakj92429852017-06-29 00:19:03111}
112
Scott Violet7e33efc2018-08-29 22:30:15113namespace ws {
114class ContextProviderCommandBuffer;
115class Gpu;
116} // namespace ws
117
[email protected]64ffa0442011-10-03 22:08:36118namespace content {
[email protected]e9ff79c2012-10-19 21:31:26119
[email protected]eb398192012-10-22 20:16:19120class AppCacheDispatcher;
[email protected]da9f30a2014-06-18 19:39:04121class AecDumpMessageFilter;
[email protected]3958e972012-07-17 00:25:41122class AudioRendererMixerManager;
fsamuel6c1dfeb2014-12-18 19:21:33123class BrowserPluginManager;
John Abd-El-Maleke1d4de32017-10-21 16:14:29124class CategorizedWorkerPool;
[email protected]e9ff79c2012-10-19 21:31:26125class DomStorageDispatcher;
danakj83066a32016-06-21 02:34:49126class FrameSwapMessageQueue;
John Abd-El-Maleke1d4de32017-10-21 16:14:29127class GpuVideoAcceleratorFactoriesImpl;
Robert Sesek6e3d725c2018-06-06 14:38:02128class LowMemoryModeController;
Adithya Srinivasane8ada8062018-11-28 17:17:34129class MidiSessionClientImpl;
[email protected]4761cf12012-09-12 10:37:55130class P2PSocketDispatcher;
jsbellabadb9b2015-03-23 21:03:44131class PeerConnectionDependencyFactory;
[email protected]af089972013-01-10 04:04:40132class PeerConnectionTracker;
tyoshino832a58a2016-04-18 08:14:08133class RenderThreadObserver;
tfarina556a7232014-10-05 01:02:09134class RendererBlinkPlatformImpl;
John Abd-El-Malek6b56ef712017-10-21 22:52:46135class ResourceDispatcher;
[email protected]9a292e22012-10-22 15:19:31136class VideoCaptureImplManager;
[email protected]cb25aa12012-08-07 19:13:43137
boliubee541f42015-11-05 00:52:53138#if defined(OS_ANDROID)
siva.gunturi5d4feb052015-11-15 16:15:31139class StreamTextureFactory;
boliubee541f42015-11-05 00:52:53140#endif
141
jam8a021512a2015-02-03 18:16:08142#if defined(COMPILER_MSVC)
143// See explanation for other RenderViewHostImpl which is the same issue.
144#pragma warning(push)
145#pragma warning(disable: 4250)
146#endif
147
[email protected]f1a29a02011-10-06 23:08:44148// The RenderThreadImpl class represents a background thread where RenderView
initial.commit09911bf2008-07-26 23:55:29149// instances live. The RenderThread supports an API that is used by its
150// consumer to talk indirectly to the RenderViews and supporting objects.
151// Likewise, it provides an API for the RenderViews to talk back to the main
[email protected]770005b2012-04-16 15:58:13152// process (i.e., their corresponding WebContentsImpl).
initial.commit09911bf2008-07-26 23:55:29153//
154// Most of the communication occurs in the form of IPC messages. They are
155// routed to the RenderThread according to the routing IDs of the messages.
156// The routing IDs correspond to RenderView instances.
danakj6e3bf8012014-12-16 18:27:53157class CONTENT_EXPORT RenderThreadImpl
158 : public RenderThread,
jam8a021512a2015-02-03 18:16:08159 public ChildThreadImpl,
Kent Tamura38fb4342018-07-25 12:47:53160 public blink::scheduler::WebRAILModeObserver,
Nico Weber43ddd7a32017-08-15 19:19:27161 public mojom::Renderer,
danakjab9ef4d2017-10-31 23:38:33162 public viz::mojom::CompositingModeWatcher,
Nico Weber43ddd7a32017-08-15 19:19:27163 public CompositorDependencies {
initial.commit09911bf2008-07-26 23:55:29164 public:
[email protected]f1a29a02011-10-06 23:08:44165 static RenderThreadImpl* current();
rockot5c478a72016-09-28 23:14:18166 static mojom::RenderMessageFilter* current_render_message_filter();
olegmax045f7fb12017-05-19 07:58:55167 static RendererBlinkPlatformImpl* current_blink_platform_impl();
rockot5c478a72016-09-28 23:14:18168
169 static void SetRenderMessageFilterForTesting(
170 mojom::RenderMessageFilter* render_message_filter);
olegmax045f7fb12017-05-19 07:58:55171 static void SetRendererBlinkPlatformImplForTesting(
172 RendererBlinkPlatformImpl* blink_platform_impl);
[email protected]526476902011-10-06 20:34:06173
John Abd-El-Malekd4882642017-12-04 21:45:19174 // Returns the task runner for the main thread where the RenderThread lives.
Hajime Hoshi20578c62018-01-12 09:43:26175 static scoped_refptr<base::SingleThreadTaskRunner>
176 DeprecatedGetMainTaskRunner();
John Abd-El-Malekd4882642017-12-04 21:45:19177
Wez6979109b2018-09-07 17:30:56178 RenderThreadImpl(
179 base::RepeatingClosure quit_closure,
Greg Kraynovf5d60272018-08-10 12:28:51180 std::unique_ptr<blink::scheduler::WebThreadScheduler> scheduler);
181 RenderThreadImpl(
182 const InProcessChildThreadParams& params,
183 std::unique_ptr<blink::scheduler::WebThreadScheduler> scheduler);
dcheng6d18e402014-10-21 12:32:52184 ~RenderThreadImpl() override;
185 void Shutdown() override;
harakenbbfdd9f02017-01-12 07:14:04186 bool ShouldBeDestroyed() override;
initial.commit09911bf2008-07-26 23:55:29187
[email protected]58436a12012-03-21 17:10:26188 // When initializing WebKit, ensure that any schemes needed for the content
189 // module are registered properly. Static to allow sharing with tests.
190 static void RegisterSchemes();
191
[email protected]e9ff79c2012-10-19 21:31:26192 // RenderThread implementation:
dcheng6d18e402014-10-21 12:32:52193 bool Send(IPC::Message* msg) override;
dcheng6d18e402014-10-21 12:32:52194 IPC::SyncChannel* GetChannel() override;
195 std::string GetLocale() override;
196 IPC::SyncMessageFilter* GetSyncMessageFilter() override;
avi1023d012015-12-25 02:39:14197 void AddRoute(int32_t routing_id, IPC::Listener* listener) override;
198 void RemoveRoute(int32_t routing_id) override;
dcheng6d18e402014-10-21 12:32:52199 int GenerateRoutingID() override;
200 void AddFilter(IPC::MessageFilter* filter) override;
201 void RemoveFilter(IPC::MessageFilter* filter) override;
tyoshino832a58a2016-04-18 08:14:08202 void AddObserver(RenderThreadObserver* observer) override;
203 void RemoveObserver(RenderThreadObserver* observer) override;
dcheng6d18e402014-10-21 12:32:52204 void SetResourceDispatcherDelegate(
mohan.reddyee0b42a2014-10-08 04:53:14205 ResourceDispatcherDelegate* delegate) override;
dchengcedca5612016-04-09 01:40:15206 std::unique_ptr<base::SharedMemory> HostAllocateSharedMemoryBuffer(
mohan.reddyee0b42a2014-10-08 04:53:14207 size_t buffer_size) override;
dcheng6d18e402014-10-21 12:32:52208 void RegisterExtension(v8::Extension* extension) override;
dcheng6d18e402014-10-21 12:32:52209 int PostTaskToAllWebWorkers(const base::Closure& closure) override;
210 bool ResolveProxy(const GURL& url, std::string* proxy_list) override;
211 base::WaitableEvent* GetShutdownEvent() override;
staraz067f58242016-11-07 21:06:41212 int32_t GetClientId() override;
Nasko Oskov3d0d1dc2018-09-25 03:57:13213 bool IsOnline() override;
Karan Bhatiac89897f2017-08-10 01:06:40214 void SetRendererProcessType(
Yuta Kitamura63593502018-11-12 09:27:13215 blink::scheduler::WebRendererProcessType type) override;
Lucas Furukawa Gadanid51ff5d62018-12-07 21:26:49216 blink::WebString GetUserAgent() override;
[email protected]1223d6ef2011-03-28 16:47:50217
rockot067ca55f2016-09-30 22:00:15218 // IPC::Listener implementation via ChildThreadImpl:
219 void OnAssociatedInterfaceRequest(
220 const std::string& name,
221 mojo::ScopedInterfaceEndpointHandle handle) override;
222
weilifabbf7572017-05-22 19:05:16223 // ChildThread implementation via ChildThreadImpl:
224 scoped_refptr<base::SingleThreadTaskRunner> GetIOTaskRunner() override;
225
danakj6e3bf8012014-12-16 18:27:53226 // CompositorDependencies implementation.
danakj6e3bf8012014-12-16 18:27:53227 bool IsGpuRasterizationForced() override;
senorblancob60ba952015-01-27 19:12:36228 int GetGpuRasterizationMSAASampleCount() override;
danakj6e3bf8012014-12-16 18:27:53229 bool IsLcdTextEnabled() override;
danakj6e3bf8012014-12-16 18:27:53230 bool IsZeroCopyEnabled() override;
ericrk1d17f752015-10-20 03:03:07231 bool IsPartialRasterEnabled() override;
ccameronc7fcd132015-11-03 20:14:31232 bool IsGpuMemoryBufferCompositorResourcesEnabled() override;
ccamerona7644752014-12-30 01:16:31233 bool IsElasticOverscrollEnabled() override;
danakj4b347212018-07-04 17:55:17234 bool IsUseZoomForDSFEnabled() override;
danakj6e3bf8012014-12-16 18:27:53235 scoped_refptr<base::SingleThreadTaskRunner>
236 GetCompositorMainThreadTaskRunner() override;
237 scoped_refptr<base::SingleThreadTaskRunner>
238 GetCompositorImplThreadTaskRunner() override;
Yuta Kitamuradeb91bb2018-05-29 05:53:20239 blink::scheduler::WebThreadScheduler* GetWebMainThreadScheduler() override;
reveman34b7a1522015-03-23 20:27:47240 cc::TaskGraphRunner* GetTaskGraphRunner() override;
wjmaclean1d970622017-01-21 22:28:24241 bool IsScrollAnimatorEnabled() override;
Khushal3e96e662017-10-30 23:16:50242 std::unique_ptr<cc::UkmRecorderFactory> CreateUkmRecorderFactory() override;
danakj4b347212018-07-04 17:55:17243#ifdef OS_ANDROID
244 bool UsingSynchronousCompositing() override;
245#endif
danakj6e3bf8012014-12-16 18:27:53246
danakje6da4f12018-07-04 17:41:30247 bool IsThreadedAnimationEnabled();
248
Kent Tamura38fb4342018-07-25 12:47:53249 // blink::scheduler::WebRAILModeObserver implementation.
skyostila37c2a72016-06-29 17:30:07250 void OnRAILModeChanged(v8::RAILMode rail_mode) override;
251
danakjab9ef4d2017-10-31 23:38:33252 // viz::mojom::CompositingModeWatcher implementation.
253 void CompositingModeFallbackToSoftware() override;
254
255 // Whether gpu compositing is being used or is disabled for software
256 // compositing. Clients of the compositor should give resources that match
257 // the appropriate mode.
258 bool IsGpuCompositingDisabled() { return is_gpu_compositing_disabled_; }
259
[email protected]b3e83de2012-02-07 03:33:28260 // Synchronously establish a channel to the GPU plugin if not previously
261 // established or if it has been lost (for example if the GPU plugin crashed).
262 // If there is a pending asynchronous request, it will be completed by the
Bo Liud1ef1c32017-12-08 06:15:50263 // time this routine returns.
264 scoped_refptr<gpu::GpuChannelHost> EstablishGpuChannelSync();
[email protected]b3e83de2012-02-07 03:33:28265
pimanc44437a22016-10-29 00:09:22266 gpu::GpuMemoryBufferManager* GetGpuMemoryBufferManager();
267
Scott Violetb04f16c2018-11-27 00:48:46268 using LayerTreeFrameSinkCallback =
269 base::OnceCallback<void(std::unique_ptr<cc::LayerTreeFrameSink>)>;
270 void RequestNewLayerTreeFrameSink(
danakjf87460792018-12-04 20:14:22271 int widget_routing_id,
danakj83066a32016-06-21 02:34:49272 scoped_refptr<FrameSwapMessageQueue> frame_swap_message_queue,
fsamuelcf3002e2017-03-20 23:13:47273 const GURL& url,
Scott Violetb04f16c2018-11-27 00:48:46274 LayerTreeFrameSinkCallback callback,
jonrossa2ff4f82018-02-16 17:27:46275 mojom::RenderFrameMetadataObserverClientRequest
276 render_frame_metadata_observer_client_request,
yiyix6b90ef52018-10-09 19:55:30277 mojom::RenderFrameMetadataObserverPtr render_frame_metadata_observer_ptr,
278 const char* client_name);
danakj83066a32016-06-21 02:34:49279
Sam McNally52e50282017-11-29 00:54:02280 blink::AssociatedInterfaceRegistry* GetAssociatedInterfaceRegistry();
rockot067ca55f2016-09-30 22:00:15281
Kent Tamura21d1de62018-12-10 04:45:20282 std::unique_ptr<cc::SwapPromise> RequestCopyOfOutputForWebTest(
danakjf87460792018-12-04 20:14:22283 int32_t widget_routing_id,
Fady Samueldfecb7d2017-07-26 11:41:04284 std::unique_ptr<viz::CopyOutputRequest> request);
jbroman6ccbc7d472016-07-27 04:45:41285
Kent Tamura2eab5b12018-12-07 04:31:23286 // True if we are running web tests. This currently disables forwarding
[email protected]70dee7e2013-05-29 18:28:30287 // various status messages to the console, skips network error pages, and
288 // short circuits size update and focus events.
Kent Tamura2eab5b12018-12-07 04:31:23289 bool web_test_mode() const { return !!web_test_deps_; }
290 void set_web_test_dependencies(std::unique_ptr<WebTestDependencies> deps) {
291 web_test_deps_ = std::move(deps);
[email protected]ac7f5a02013-03-16 16:14:41292 }
Kent Tamura2eab5b12018-12-07 04:31:23293 // Returns whether we are running web tests with display compositor for
Mounir Lamouri9c99a1602018-07-05 15:01:44294 // pixel dump enabled. It is meant to disable feature that require display
295 // compositor while it is not enabled by default.
Kent Tamura21d1de62018-12-10 04:45:20296 // This should only be called if currently running in web tests.
Kent Tamura2eab5b12018-12-07 04:31:23297 bool WebTestModeUsesDisplayCompositorPixelDump() const {
298 DCHECK(web_test_deps_);
299 return web_test_deps_->UseDisplayCompositorPixelDump();
Mounir Lamouri9c99a1602018-07-05 15:01:44300 }
[email protected]ac7f5a02013-03-16 16:14:41301
penghuang342762b2016-12-02 21:04:58302 discardable_memory::ClientDiscardableSharedMemoryManager*
303 GetDiscardableSharedMemoryManagerForTest() {
304 return discardable_shared_memory_manager_.get();
305 }
306
tfarina556a7232014-10-05 01:02:09307 RendererBlinkPlatformImpl* blink_platform_impl() const {
308 DCHECK(blink_platform_impl_);
309 return blink_platform_impl_.get();
[email protected]078780b2014-06-20 16:57:06310 }
311
Yuta Kitamura4e256bfc2018-09-27 06:32:35312 // Returns the task runner on the compositor thread.
313 //
danakj6e3bf8012014-12-16 18:27:53314 // Will be null if threaded compositing has not been enabled.
skyostil2d3b5bd2015-05-27 15:40:59315 scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner() const {
316 return compositor_task_runner_;
[email protected]a9fb30aa2011-10-06 06:58:46317 }
318
[email protected]f430b5712009-08-21 21:46:31319 AppCacheDispatcher* appcache_dispatcher() const {
320 return appcache_dispatcher_.get();
321 }
322
[email protected]19b49512012-05-30 19:22:09323 DomStorageDispatcher* dom_storage_dispatcher() const {
324 return dom_storage_dispatcher_.get();
325 }
326
Adithya Srinivasane8ada8062018-11-28 17:17:34327 MidiSessionClientImpl* midi_session_client_impl() {
328 return midi_session_client_impl_.get();
[email protected]a9875152013-06-22 04:03:03329 }
[email protected]6ee10bd2012-09-13 09:01:53330
John Abd-El-Malek6b56ef712017-10-21 22:52:46331 ResourceDispatcher* resource_dispatcher() const {
332 return resource_dispatcher_.get();
333 }
334
Yuzhu Shenfe5f3a52018-01-11 21:24:13335 URLLoaderThrottleProvider* url_loader_throttle_provider() const {
336 return url_loader_throttle_provider_.get();
337 }
338
[email protected]6ca6a082013-09-22 20:10:05339#if defined(OS_ANDROID)
siva.gunturi5d4feb052015-11-15 16:15:31340 scoped_refptr<StreamTextureFactory> GetStreamTexureFactory();
boliuf8753bf62016-02-11 20:09:42341 bool EnableStreamTextureCopy();
[email protected]6ca6a082013-09-22 20:10:05342#endif
343
[email protected]d8cd8372012-03-09 10:49:51344 // Creates the embedder implementation of WebMediaStreamCenter.
345 // The resulting object is owned by WebKit and deleted by WebKit at tear-down.
Guido Urdaneta75294fa2018-06-14 14:20:29346 std::unique_ptr<blink::WebMediaStreamCenter> CreateMediaStreamCenter();
[email protected]d8cd8372012-03-09 10:49:51347
fsamuel6c1dfeb2014-12-18 19:21:33348 BrowserPluginManager* browser_plugin_manager() const {
349 return browser_plugin_manager_.get();
350 }
351
[email protected]6ee10bd2012-09-13 09:01:53352 // Returns a factory used for creating RTC PeerConnection objects.
[email protected]0107d8a2014-05-16 10:20:34353 PeerConnectionDependencyFactory* GetPeerConnectionDependencyFactory();
[email protected]6ee10bd2012-09-13 09:01:53354
[email protected]af089972013-01-10 04:04:40355 PeerConnectionTracker* peer_connection_tracker() {
356 return peer_connection_tracker_.get();
357 }
358
[email protected]4761cf12012-09-12 10:37:55359 // Current P2PSocketDispatcher. Set to NULL if P2P API is disabled.
[email protected]e9ff79c2012-10-19 21:31:26360 P2PSocketDispatcher* p2p_socket_dispatcher() {
[email protected]4761cf12012-09-12 10:37:55361 return p2p_socket_dispatcher_.get();
362 }
363
[email protected]80b161a2011-06-27 17:42:11364 VideoCaptureImplManager* video_capture_impl_manager() const {
365 return vc_manager_.get();
366 }
367
Robert Sesek6e3d725c2018-06-06 14:38:02368 LowMemoryModeController* low_memory_mode_controller() const {
369 return low_memory_mode_controller_.get();
370 }
371
rockot1587e332016-07-27 17:44:14372 mojom::RenderFrameMessageFilter* render_frame_message_filter();
rockote261d2112016-09-21 22:22:23373 mojom::RenderMessageFilter* render_message_filter();
rockot1587e332016-07-27 17:44:14374
[email protected]6217d392010-03-25 22:08:35375 // Get the GPU channel. Returns NULL if the channel is not established or
376 // has been lost.
penghuang346a46f92016-03-31 21:37:52377 gpu::GpuChannelHost* GetGpuChannel();
[email protected]6217d392010-03-25 22:08:35378
skyostil2d3b5bd2015-05-27 15:40:59379 // Returns a SingleThreadTaskRunner instance corresponding to the message loop
[email protected]c1330c82013-06-06 02:23:25380 // of the thread on which media operations should be run. Must be called
381 // on the renderer's main thread.
acolwellb4034942014-08-28 15:42:43382 scoped_refptr<base::SingleThreadTaskRunner> GetMediaThreadTaskRunner();
[email protected]c1330c82013-06-06 02:23:25383
dcastagna4517a182015-08-05 19:51:03384 // A TaskRunner instance that runs tasks on the raster worker pool.
385 base::TaskRunner* GetWorkerTaskRunner();
dcastagnab880e8f2015-06-30 20:16:06386
CJ DiMeglio79f7c91a22018-08-30 22:24:43387 // Creates a ContextProvider if yet created, and returns it to be used for
388 // video frame compositing. The ContextProvider given as an argument is
389 // one that has been lost, and is a hint to the RenderThreadImpl to clear
390 // it's |video_frame_compositor_context_provider_| if it matches.
391 scoped_refptr<viz::ContextProvider> GetVideoFrameCompositorContextProvider(
392 scoped_refptr<viz::ContextProvider>);
393
danakj0b4b94e32016-05-10 22:33:01394 // Returns a worker context provider that will be bound on the compositor
395 // thread.
Victor Miuraff6488612017-12-21 04:16:15396 scoped_refptr<viz::RasterContextProvider>
Jonathan Backer8e4f35d2018-10-15 20:56:42397 SharedCompositorWorkerContextProvider(bool try_gpu_rasterization);
revemand180dfc32015-09-24 00:19:43398
dcastagna7f45dada2015-10-19 20:17:35399 media::GpuVideoAcceleratorFactories* GetGpuFactories();
[email protected]3bb8bb32013-07-11 13:13:03400
Scott Violet7e33efc2018-08-29 22:30:15401 scoped_refptr<ws::ContextProviderCommandBuffer>
sadrul85cc5d82016-12-20 03:37:41402 SharedMainThreadContextProvider();
[email protected]c29b7ff2013-03-06 03:51:04403
[email protected]3958e972012-07-17 00:25:41404 // AudioRendererMixerManager instance which manages renderer side mixer
405 // instances shared based on configured audio parameters. Lazily created on
406 // first call.
[email protected]e9ff79c2012-10-19 21:31:26407 AudioRendererMixerManager* GetAudioRendererMixerManager();
[email protected]3958e972012-07-17 00:25:41408
[email protected]feb32372012-11-21 01:14:56409#if defined(OS_WIN)
[email protected]fcf75d42013-12-03 20:11:26410 void PreCacheFontCharacters(const LOGFONT& log_font,
411 const base::string16& str);
[email protected]feb32372012-11-21 01:14:56412#endif
413
[email protected]b2d98762012-09-03 17:04:06414 // For producing custom V8 histograms. Custom histograms are produced if all
415 // RenderViews share the same host, and the host is in the pre-specified set
416 // of hosts we want to produce custom diagrams for. The name for a custom
417 // diagram is the name of the corresponding generic diagram plus a
418 // host-specific suffix.
419 class CONTENT_EXPORT HistogramCustomizer {
420 public:
421 HistogramCustomizer();
422 ~HistogramCustomizer();
423
424 // Called when a top frame of a RenderView navigates. This function updates
425 // RenderThreadImpl's information about whether all RenderViews are
426 // displaying a page from the same host. |host| is the host where a
427 // RenderView navigated, and |view_count| is the number of RenderViews in
428 // this process.
429 void RenderViewNavigatedToHost(const std::string& host, size_t view_count);
430
431 // Used for customizing some histograms if all RenderViews share the same
432 // host. Returns the current custom histogram name to use for
433 // |histogram_name|, or |histogram_name| if it shouldn't be customized.
434 std::string ConvertToCustomHistogramName(const char* histogram_name) const;
435
436 private:
hablichd6a4f122015-10-28 11:34:49437 FRIEND_TEST_ALL_PREFIXES(RenderThreadImplUnittest,
438 IdentifyAlexaTop10NonGoogleSite);
[email protected]b2d98762012-09-03 17:04:06439 friend class RenderThreadImplUnittest;
440
hablichd6a4f122015-10-28 11:34:49441 // Converts a host name to a suffix for histograms
442 std::string HostToCustomHistogramSuffix(const std::string& host);
443
444 // Helper function to identify a certain set of top pages
445 bool IsAlexaTop10NonGoogleSite(const std::string& host);
446
[email protected]b2d98762012-09-03 17:04:06447 // Used for updating the information on which is the common host which all
448 // RenderView's share (if any). If there is no common host, this function is
449 // called with an empty string.
450 void SetCommonHost(const std::string& host);
451
452 // The current common host of the RenderViews; empty string if there is no
453 // common host.
454 std::string common_host_;
455 // The corresponding suffix.
456 std::string common_host_histogram_suffix_;
457 // Set of histograms for which we want to produce a custom histogram if
458 // possible.
459 std::set<std::string> custom_histograms_;
460
461 DISALLOW_COPY_AND_ASSIGN(HistogramCustomizer);
462 };
463
464 HistogramCustomizer* histogram_customizer() {
465 return &histogram_customizer_;
466 }
467
[email protected]b2db9272014-01-10 17:42:00468 // Called by a RenderWidget when it is created or destroyed. This
469 // allows the process to know when there are no visible widgets.
470 void WidgetCreated();
rmcilroyaa296052015-04-14 15:35:27471 // Note: A widget must not be hidden when it is destroyed - ensure that
472 // WidgetRestored is called before WidgetDestroyed for any hidden widget.
[email protected]b2db9272014-01-10 17:42:00473 void WidgetDestroyed();
474 void WidgetHidden();
475 void WidgetRestored();
476
benf28ce882017-05-02 16:15:49477 void RegisterPendingFrameCreate(
478 const service_manager::BindSourceInfo& source_info,
479 int routing_id,
Balazs Engedyba034e72017-10-27 22:26:28480 mojom::FrameRequest frame);
rockotf8fdd9b2015-12-16 22:22:35481
Marijn Kruisselbrink4712c332018-06-13 19:06:59482 blink::mojom::StoragePartitionService* GetStoragePartitionService();
jam188f19f2017-06-07 03:56:24483 mojom::RendererHost* GetRendererHost();
jamc912ca32016-02-24 20:17:31484
keishi51ed0d52017-01-12 10:04:46485 struct RendererMemoryMetrics {
486 size_t partition_alloc_kb;
487 size_t blink_gc_kb;
488 size_t malloc_mb;
489 size_t discardable_kb;
490 size_t v8_main_thread_isolate_mb;
491 size_t total_allocated_mb;
492 size_t non_discardable_total_allocated_mb;
493 size_t total_allocated_per_render_view_mb;
494 };
bashia0ba0d42017-04-03 08:11:06495 bool GetRendererMemoryMetrics(RendererMemoryMetrics* memory_metrics) const;
keishi51ed0d52017-01-12 10:04:46496
Takashi SAKAMOTO870f6262017-08-22 04:08:27497 bool NeedsToRecordFirstActivePaint(int metric_type) const;
tasakb95dbb50c2017-02-08 18:07:50498
Miguel Casas5e1018052018-01-09 19:17:36499 // Sets the current pipeline rendering color space.
500 void SetRenderingColorSpace(const gfx::ColorSpace& color_space);
501
CJ DiMeglio79f7c91a22018-08-30 22:24:43502 scoped_refptr<base::SingleThreadTaskRunner>
503 CreateVideoFrameCompositorTaskRunner();
504
CJ DiMegliob6eb9cd2018-11-06 23:44:01505 // In the case of kOnDemand, we wont be using the task_runner created in
506 // CreateVideoFrameCompositorTaskRunner.
507 // TODO(https://crbug/901513): Remove once kOnDemand is removed.
508 void SetVideoFrameCompositorTaskRunner(
509 scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
510 video_frame_compositor_task_runner_ = task_runner;
511 }
512
[email protected]8930d472009-02-21 08:05:28513 private:
Nicholas Verne06de8122017-11-16 04:47:38514 void OnProcessFinalRelease() override;
torne88b66452016-05-03 13:22:14515 // IPC::Listener
516 void OnChannelError() override;
517
[email protected]57cf97882013-06-26 20:39:01518 // ChildThread
dcheng6d18e402014-10-21 12:32:52519 bool OnControlMessageReceived(const IPC::Message& msg) override;
liberato3aeeb2c2016-02-25 17:54:38520 void RecordAction(const base::UserMetricsAction& action) override;
521 void RecordComputedAction(const std::string& action) override;
initial.commit09911bf2008-07-26 23:55:29522
sadrul53546592016-12-17 01:44:21523 bool IsMainThread();
[email protected]57cf97882013-06-26 20:39:01524
bashib9058f282017-03-30 01:55:24525 void RecordPurgeMemory(RendererMemoryMetrics before);
526
Greg Kraynovf5d60272018-08-10 12:28:51527 void Init();
vollick1050cc62015-12-03 07:04:54528 void InitializeCompositorThread();
Greg Kraynovf5d60272018-08-10 12:28:51529 void InitializeWebKit(service_manager::BinderRegistry* registry);
jam75c44222016-03-23 05:34:24530
initial.commit09911bf2008-07-26 23:55:29531 void OnTransferBitmap(const SkBitmap& bitmap, int resource_id);
[email protected]b3df5a42010-05-11 14:31:09532 void OnGetAccessibilityTree();
blundellc00adf442016-09-16 10:43:41533
rockot067ca55f2016-09-30 22:00:15534 // mojom::Renderer:
Ben Goodger16331302018-01-23 00:43:21535 void CreateEmbedderRendererService(
536 service_manager::mojom::ServiceRequest service_request) override;
rockot067ca55f2016-09-30 22:00:15537 void CreateView(mojom::CreateViewParamsPtr params) override;
rockot53be7caf2016-10-04 20:17:08538 void CreateFrame(mojom::CreateFrameParamsPtr params) override;
Dmitry Gozman89361212018-02-13 16:10:44539 void CreateFrameProxy(
540 int32_t routing_id,
541 int32_t render_view_routing_id,
542 int32_t opener_routing_id,
543 int32_t parent_routing_id,
544 const FrameReplicationState& replicated_state,
545 const base::UnguessableToken& devtools_frame_token) override;
Makoto Shimazu8199e092018-05-11 06:03:14546 void SetUpEmbeddedWorkerChannelForServiceWorker(
547 mojom::EmbeddedWorkerInstanceClientRequest client_request) override;
rockota2db0da2016-10-18 17:39:11548 void OnNetworkConnectionChanged(
549 net::NetworkChangeNotifier::ConnectionType type,
550 double max_bandwidth_mbps) override;
tbansalb612c5d2017-05-25 18:53:06551 void OnNetworkQualityChanged(net::EffectiveConnectionType type,
552 base::TimeDelta http_rtt,
tbansal99d8aeb2017-05-22 19:12:58553 base::TimeDelta transport_rtt,
tbansal15973c32017-05-10 18:40:44554 double bandwidth_kbps) override;
rockota2db0da2016-10-18 17:39:11555 void SetWebKitSharedTimersSuspended(bool suspend) override;
Yutaka Hiranob0465f72018-05-17 05:48:25556 void SetUserAgent(const std::string& user_agent) override;
rockota2db0da2016-10-18 17:39:11557 void UpdateScrollbarTheme(
558 mojom::UpdateScrollbarThemeParamsPtr params) override;
559 void OnSystemColorsChanged(int32_t aqua_color_variant,
560 const std::string& highlight_text_color,
561 const std::string& highlight_color) override;
562 void PurgePluginListCache(bool reload_pages) override;
Nicholas Verne5420564d2017-10-27 07:37:54563 void SetProcessBackgrounded(bool backgrounded) override;
Shubhie Panicker45ce80a82018-02-01 01:40:19564 void SetSchedulerKeepActive(bool keep_active) override;
Nicholas Verne5420564d2017-10-27 07:37:54565 void ProcessPurgeAndSuspend() override;
Nicolas Pena7c7847f2018-05-30 01:36:05566 void SetIsLockedToSite() override;
Robert Sesek6e3d725c2018-06-06 14:38:02567 void EnableV8LowMemoryMode() override;
rockot067ca55f2016-09-30 22:00:15568
[email protected]5071cb22013-07-10 02:19:06569 void OnMemoryPressure(
570 base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level);
rockota2db0da2016-10-18 17:39:11571
rmcilroyaa296052015-04-14 15:35:27572 bool RendererIsHidden() const;
573 void OnRendererHidden();
574 void OnRendererVisible();
[email protected]b3df5a42010-05-11 14:31:09575
tasak335a1872017-06-14 09:50:23576 void RecordMemoryUsageAfterBackgrounded(const char* suffix,
577 int foregrounded_count);
tasakbb0640b2017-05-15 09:02:26578 void RecordPurgeAndSuspendMemoryGrowthMetrics(
579 const char* suffix,
580 int foregrounded_count_when_purged);
tasakb46626a2016-10-18 05:54:44581
ssid0603ca9f2015-06-09 16:48:08582 void ReleaseFreeMemory();
583
hong.zhengb28b5332016-05-11 02:33:39584 void OnSyncMemoryPressure(
585 base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level);
586
Fady Samuelc645ffe2017-07-24 17:28:20587 std::unique_ptr<viz::SyntheticBeginFrameSource>
samans09812d32017-03-27 19:51:50588 CreateSyntheticBeginFrameSource();
589
rockot067ca55f2016-09-30 22:00:15590 void OnRendererInterfaceRequest(mojom::RendererAssociatedRequest request);
591
penghuang342762b2016-12-02 21:04:58592 std::unique_ptr<discardable_memory::ClientDiscardableSharedMemoryManager>
593 discardable_shared_memory_manager_;
594
initial.commit09911bf2008-07-26 23:55:29595 // These objects live solely on the render thread.
dchengcedca5612016-04-09 01:40:15596 std::unique_ptr<AppCacheDispatcher> appcache_dispatcher_;
597 std::unique_ptr<DomStorageDispatcher> dom_storage_dispatcher_;
Yuta Kitamuradeb91bb2018-05-29 05:53:20598 std::unique_ptr<blink::scheduler::WebThreadScheduler> main_thread_scheduler_;
dchengcedca5612016-04-09 01:40:15599 std::unique_ptr<RendererBlinkPlatformImpl> blink_platform_impl_;
John Abd-El-Malek6b56ef712017-10-21 22:52:46600 std::unique_ptr<ResourceDispatcher> resource_dispatcher_;
Yuzhu Shenfe5f3a52018-01-11 21:24:13601 std::unique_ptr<URLLoaderThrottleProvider> url_loader_throttle_provider_;
[email protected]9291ed12009-07-23 17:33:22602
[email protected]e2b2d4a2009-10-24 03:32:59603 // Used on the renderer and IPC threads.
Adithya Srinivasane8ada8062018-11-28 17:17:34604 std::unique_ptr<MidiSessionClientImpl> midi_session_client_impl_;
[email protected]017022b2009-07-27 23:06:34605
dchengcedca5612016-04-09 01:40:15606 std::unique_ptr<BrowserPluginManager> browser_plugin_manager_;
fsamuel6c1dfeb2014-12-18 19:21:33607
dchengcedca5612016-04-09 01:40:15608 std::unique_ptr<PeerConnectionDependencyFactory> peer_connection_factory_;
[email protected]6ee10bd2012-09-13 09:01:53609
[email protected]af089972013-01-10 04:04:40610 // This is used to communicate to the browser process the status
611 // of all the peer connections created in the renderer.
dchengcedca5612016-04-09 01:40:15612 std::unique_ptr<PeerConnectionTracker> peer_connection_tracker_;
[email protected]af089972013-01-10 04:04:40613
[email protected]4761cf12012-09-12 10:37:55614 // Dispatches all P2P sockets.
[email protected]e9ff79c2012-10-19 21:31:26615 scoped_refptr<P2PSocketDispatcher> p2p_socket_dispatcher_;
[email protected]80b161a2011-06-27 17:42:11616
[email protected]da9f30a2014-06-18 19:39:04617 // Used for communicating registering AEC dump consumers with the browser and
618 // receving AEC dump file handles when AEC dump is enabled. An AEC dump is
619 // diagnostic audio data for WebRTC stored locally when enabled by the user in
620 // chrome://webrtc-internals.
621 scoped_refptr<AecDumpMessageFilter> aec_dump_message_filter_;
liushouqun517b1292016-09-14 05:58:59622
Max Morin3d464a42018-01-15 11:17:00623 // Provides AudioInputIPC objects for audio input devices. Initialized in
624 // Init.
625 base::Optional<AudioInputIPCFactory> audio_input_ipc_factory_;
Max Morin2c38c282018-04-17 07:01:42626 // Provides AudioOutputIPC objects for audio output devices. Initialized in
627 // Init.
Max Morin3d464a42018-01-15 11:17:00628 base::Optional<AudioOutputIPCFactory> audio_output_ipc_factory_;
maxmorin017ba8c62017-06-02 10:23:09629
liushouqun517b1292016-09-14 05:58:59630 // Used on the render thread.
631 std::unique_ptr<VideoCaptureImplManager> vc_manager_;
[email protected]da9f30a2014-06-18 19:39:04632
[email protected]bee16aab2009-08-26 15:55:03633 // The count of RenderWidgets running through this thread.
634 int widget_count_;
635
636 // The count of hidden RenderWidgets running through this thread.
637 int hidden_widget_count_;
638
Yutaka Hiranob0465f72018-05-17 05:48:25639 blink::WebString user_agent_;
640
Kent Tamura2eab5b12018-12-07 04:31:23641 // Used to control web test specific behavior.
642 std::unique_ptr<WebTestDependencies> web_test_deps_;
[email protected]233567d2013-02-27 20:22:02643
danakjab9ef4d2017-10-31 23:38:33644 // Sticky once true, indicates that compositing is done without Gpu, so
645 // resources given to the compositor or to the viz service should be
646 // software-based.
647 bool is_gpu_compositing_disabled_ = false;
648
dcastagna7f45dada2015-10-19 20:17:35649 // Utility class to provide GPU functionalities to media.
dcastagna09bd6b32016-02-01 21:54:28650 // TODO(dcastagna): This should be just one scoped_ptr once
651 // http://crbug.com/580386 is fixed.
652 // NOTE(dcastagna): At worst this accumulates a few bytes per context lost.
Miguel Casas-Sanchezcfcca5d52017-07-07 02:32:59653 std::vector<std::unique_ptr<GpuVideoAcceleratorFactoriesImpl>> gpu_factories_;
dcastagna7f45dada2015-10-19 20:17:35654
[email protected]c1330c82013-06-06 02:23:25655 // Thread for running multimedia operations (e.g., video decoding).
dchengcedca5612016-04-09 01:40:15656 std::unique_ptr<base::Thread> media_thread_;
[email protected]c1330c82013-06-06 02:23:25657
skyostil2d3b5bd2015-05-27 15:40:59658 // Will point to appropriate task runner after initialization,
[email protected]ea5f70a2013-03-07 12:30:36659 // regardless of whether |compositor_thread_| is overriden.
skyostil2d3b5bd2015-05-27 15:40:59660 scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner_;
[email protected]ea5f70a2013-03-07 12:30:36661
CJ DiMeglio79f7c91a22018-08-30 22:24:43662 // Task to run the VideoFrameCompositor on.
663 scoped_refptr<base::SingleThreadTaskRunner>
664 video_frame_compositor_task_runner_;
665
dcastagnab880e8f2015-06-30 20:16:06666 // Pool of workers used for raster operations (e.g., tile rasterization).
prashant.nfad657e2016-06-01 07:52:17667 scoped_refptr<CategorizedWorkerPool> categorized_worker_pool_;
reveman34b7a1522015-03-23 20:27:47668
boliubee541f42015-11-05 00:52:53669#if defined(OS_ANDROID)
siva.gunturi5d4feb052015-11-15 16:15:31670 scoped_refptr<StreamTextureFactory> stream_texture_factory_;
boliubee541f42015-11-05 00:52:53671#endif
672
Scott Violet7e33efc2018-08-29 22:30:15673 scoped_refptr<ws::ContextProviderCommandBuffer> shared_main_thread_contexts_;
[email protected]c29b7ff2013-03-06 03:51:04674
Trent Apteda250ec3ab2018-08-19 08:52:19675 base::ObserverList<RenderThreadObserver>::Unchecked observers_;
[email protected]1223d6ef2011-03-28 16:47:50676
CJ DiMeglio79f7c91a22018-08-30 22:24:43677 scoped_refptr<viz::ContextProvider> video_frame_compositor_context_provider_;
678
Victor Miuraff6488612017-12-21 04:16:15679 scoped_refptr<viz::RasterContextProvider> shared_worker_context_provider_;
[email protected]3b2afc32012-06-18 21:31:16680
dchengcedca5612016-04-09 01:40:15681 std::unique_ptr<AudioRendererMixerManager> audio_renderer_mixer_manager_;
[email protected]3958e972012-07-17 00:25:41682
[email protected]b2d98762012-09-03 17:04:06683 HistogramCustomizer histogram_customizer_;
684
dchengcedca5612016-04-09 01:40:15685 std::unique_ptr<base::MemoryPressureListener> memory_pressure_listener_;
[email protected]5071cb22013-07-10 02:19:06686
Robert Sesek6e3d725c2018-06-06 14:38:02687 // Created in response to EnableV8LowMemoryMode(), this manages V8's
688 // memory saving mode.
689 std::unique_ptr<LowMemoryModeController> low_memory_mode_controller_;
690
Scott Violet7e33efc2018-08-29 22:30:15691 std::unique_ptr<ws::Gpu> gpu_;
sadrul9e0bb1d2016-08-04 20:18:39692
skyostil457b0a12014-09-09 10:12:07693 scoped_refptr<base::SingleThreadTaskRunner>
694 main_thread_compositor_task_runner_;
skyostil457b0a12014-09-09 10:12:07695
danakj6e3bf8012014-12-16 18:27:53696 // Compositor settings.
[email protected]a23530d2014-03-11 06:04:14697 bool is_gpu_rasterization_forced_;
senorblancob60ba952015-01-27 19:12:36698 int gpu_rasterization_msaa_sample_count_;
[email protected]a23530d2014-03-11 06:04:14699 bool is_lcd_text_enabled_;
[email protected]2cccfef2014-05-01 06:05:16700 bool is_zero_copy_enabled_;
ccameronc7fcd132015-11-03 20:14:31701 bool is_gpu_memory_buffer_compositor_resources_enabled_;
ericrk1d17f752015-10-20 03:03:07702 bool is_partial_raster_enabled_;
ccamerona7644752014-12-30 01:16:31703 bool is_elastic_overscroll_enabled_;
danakj4b347212018-07-04 17:55:17704 bool is_zoom_for_dsf_enabled_;
loyso65c93c602015-08-11 05:15:57705 bool is_threaded_animation_enabled_;
wjmaclean1d970622017-01-21 22:28:24706 bool is_scroll_animator_enabled_;
[email protected]a23530d2014-03-11 06:04:14707
Miguel Casas5e1018052018-01-09 19:17:36708 // Target rendering ColorSpace.
709 gfx::ColorSpace rendering_color_space_;
710
ben76f52b242016-06-18 05:42:48711 class PendingFrameCreate : public base::RefCounted<PendingFrameCreate> {
rockotf8fdd9b2015-12-16 22:22:35712 public:
Balazs Engedyba034e72017-10-27 22:26:28713 PendingFrameCreate(const service_manager::BindSourceInfo& source_info,
714 int routing_id,
715 mojom::FrameRequest frame_request);
rockotf8fdd9b2015-12-16 22:22:35716
benf28ce882017-05-02 16:15:49717 const service_manager::BindSourceInfo& browser_info() const {
718 return browser_info_;
719 }
ben76f52b242016-06-18 05:42:48720 mojom::FrameRequest TakeFrameRequest() { return std::move(frame_request_); }
rockotf8fdd9b2015-12-16 22:22:35721
722 private:
ben76f52b242016-06-18 05:42:48723 friend class base::RefCounted<PendingFrameCreate>;
rockotf8fdd9b2015-12-16 22:22:35724
ben76f52b242016-06-18 05:42:48725 ~PendingFrameCreate();
rockotf8fdd9b2015-12-16 22:22:35726
727 // Mojo error handler.
728 void OnConnectionError();
729
benf28ce882017-05-02 16:15:49730 service_manager::BindSourceInfo browser_info_;
rockotf8fdd9b2015-12-16 22:22:35731 int routing_id_;
ben76f52b242016-06-18 05:42:48732 mojom::FrameRequest frame_request_;
rockotf8fdd9b2015-12-16 22:22:35733 };
734
ben76f52b242016-06-18 05:42:48735 using PendingFrameCreateMap =
736 std::map<int, scoped_refptr<PendingFrameCreate>>;
737 PendingFrameCreateMap pending_frame_creates_;
rockotf8fdd9b2015-12-16 22:22:35738
Marijn Kruisselbrink4712c332018-06-13 19:06:59739 blink::mojom::StoragePartitionServicePtr storage_partition_service_;
Joel Hockey3146d142017-11-15 22:27:40740 mojom::RendererHostAssociatedPtr renderer_host_;
jamc912ca32016-02-24 20:17:31741
Ken Rockot26e4e802018-07-31 15:03:33742 blink::AssociatedInterfaceRegistry associated_interfaces_;
rockot067ca55f2016-09-30 22:00:15743
744 mojo::AssociatedBinding<mojom::Renderer> renderer_binding_;
745
rockot1587e332016-07-27 17:44:14746 mojom::RenderFrameMessageFilterAssociatedPtr render_frame_message_filter_;
rockote261d2112016-09-21 22:22:23747 mojom::RenderMessageFilterAssociatedPtr render_message_filter_;
rockot1587e332016-07-27 17:44:14748
tasak72f64042017-01-19 14:02:53749 RendererMemoryMetrics purge_and_suspend_memory_metrics_;
tasakb95dbb50c2017-02-08 18:07:50750 bool needs_to_record_first_active_paint_;
Takashi SAKAMOTO870f6262017-08-22 04:08:27751 base::TimeTicks was_backgrounded_time_;
tasakbb0640b2017-05-15 09:02:26752 int process_foregrounded_count_;
Nasko Oskov3d0d1dc2018-09-25 03:57:13753 bool online_status_ = true;
hajimehoshi69093272016-05-13 08:30:58754
staraz067f58242016-11-07 21:06:41755 int32_t client_id_;
756
samans2040988b2017-04-11 23:58:35757 mojom::FrameSinkProviderPtr frame_sink_provider_;
758
danakjab9ef4d2017-10-31 23:38:33759 // A mojo connection to the CompositingModeReporter service.
760 viz::mojom::CompositingModeReporterPtr compositing_mode_reporter_;
761 // The class is a CompositingModeWatcher, which is bound to mojo through
danakj4ee301c2017-11-29 16:19:43762 // this member.
danakjab9ef4d2017-10-31 23:38:33763 mojo::Binding<viz::mojom::CompositingModeWatcher>
764 compositing_mode_watcher_binding_;
765
Ben Goodgerf180ce12018-02-09 22:54:01766 base::WeakPtrFactory<RenderThreadImpl> weak_factory_;
767
[email protected]f1a29a02011-10-06 23:08:44768 DISALLOW_COPY_AND_ASSIGN(RenderThreadImpl);
initial.commit09911bf2008-07-26 23:55:29769};
770
jam8a021512a2015-02-03 18:16:08771#if defined(COMPILER_MSVC)
772#pragma warning(pop)
773#endif
774
[email protected]e9ff79c2012-10-19 21:31:26775} // namespace content
776
[email protected]f1a29a02011-10-06 23:08:44777#endif // CONTENT_RENDERER_RENDER_THREAD_IMPL_H_