[email protected] | d3d6325d | 2012-01-03 21:17:36 | [diff] [blame] | 1 | // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
license.bot | bf09a50 | 2008-08-24 00:55:55 | [diff] [blame] | 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 4 | |
[email protected] | f1a29a0 | 2011-10-06 23:08:44 | [diff] [blame] | 5 | #ifndef CONTENT_RENDERER_RENDER_THREAD_IMPL_H_ |
| 6 | #define CONTENT_RENDERER_RENDER_THREAD_IMPL_H_ |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 7 | |
avi | 1023d01 | 2015-12-25 02:39:14 | [diff] [blame] | 8 | #include <stddef.h> |
| 9 | #include <stdint.h> |
| 10 | |
maxmorin | 017ba8c6 | 2017-06-02 10:23:09 | [diff] [blame] | 11 | #include <map> |
leon.han | 21e0e48 | 2017-02-23 04:13:32 | [diff] [blame] | 12 | #include <memory> |
[email protected] | 6779aa1 | 2011-03-29 17:32:24 | [diff] [blame] | 13 | #include <set> |
[email protected] | b68d5ed | 2009-04-16 02:41:28 | [diff] [blame] | 14 | #include <string> |
maxmorin | 017ba8c6 | 2017-06-02 10:23:09 | [diff] [blame] | 15 | #include <utility> |
[email protected] | 1bc8306 | 2009-02-06 00:16:37 | [diff] [blame] | 16 | #include <vector> |
| 17 | |
jdduke | 691dd57 | 2014-12-02 20:47:52 | [diff] [blame] | 18 | #include "base/cancelable_callback.h" |
avi | 1023d01 | 2015-12-25 02:39:14 | [diff] [blame] | 19 | #include "base/macros.h" |
hajimehoshi | 7bb3958 | 2016-10-12 04:30:57 | [diff] [blame] | 20 | #include "base/memory/memory_coordinator_client.h" |
[email protected] | 5071cb2 | 2013-07-10 02:19:06 | [diff] [blame] | 21 | #include "base/memory/memory_pressure_listener.h" |
rockot | 775ce0d | 2015-01-27 18:35:01 | [diff] [blame] | 22 | #include "base/memory/ref_counted.h" |
[email protected] | e6e30ac | 2014-01-13 21:24:39 | [diff] [blame] | 23 | #include "base/metrics/user_metrics_action.h" |
[email protected] | 1223d6ef | 2011-03-28 16:47:50 | [diff] [blame] | 24 | #include "base/observer_list.h" |
maxmorin | 017ba8c6 | 2017-06-02 10:23:09 | [diff] [blame] | 25 | #include "base/optional.h" |
[email protected] | 21aa9968 | 2013-06-11 07:17:01 | [diff] [blame] | 26 | #include "base/strings/string16.h" |
[email protected] | 8810516 | 2013-12-05 01:02:12 | [diff] [blame] | 27 | #include "base/threading/thread_checker.h" |
tbansal | 99d8aeb | 2017-05-22 19:12:58 | [diff] [blame] | 28 | #include "base/time/time.h" |
[email protected] | abb52216 | 2013-06-28 01:54:16 | [diff] [blame] | 29 | #include "base/timer/timer.h" |
[email protected] | 037fce0 | 2009-01-22 01:42:15 | [diff] [blame] | 30 | #include "build/build_config.h" |
jam | 8a021512a | 2015-02-03 18:16:08 | [diff] [blame] | 31 | #include "content/child/child_thread_impl.h" |
bashi | a626404 | 2016-09-15 04:49:51 | [diff] [blame] | 32 | #include "content/child/memory/child_memory_coordinator_impl.h" |
rockot | 067ca55f | 2016-09-30 22:00:15 | [diff] [blame] | 33 | #include "content/common/associated_interface_registry_impl.h" |
[email protected] | 8d128d6 | 2011-09-13 22:11:57 | [diff] [blame] | 34 | #include "content/common/content_export.h" |
ben | 76f52b24 | 2016-06-18 05:42:48 | [diff] [blame] | 35 | #include "content/common/frame.mojom.h" |
alexmos | bc7eafa | 2014-12-06 01:38:09 | [diff] [blame] | 36 | #include "content/common/frame_replication_state.h" |
samans | 2040988b | 2017-04-11 23:58:35 | [diff] [blame] | 37 | #include "content/common/frame_sink_provider.mojom.h" |
rockot | 1587e33 | 2016-07-27 17:44:14 | [diff] [blame] | 38 | #include "content/common/render_frame_message_filter.mojom.h" |
rockot | e261d211 | 2016-09-21 22:22:23 | [diff] [blame] | 39 | #include "content/common/render_message_filter.mojom.h" |
rockot | 067ca55f | 2016-09-30 22:00:15 | [diff] [blame] | 40 | #include "content/common/renderer.mojom.h" |
jam | 188f19f | 2017-06-07 03:56:24 | [diff] [blame] | 41 | #include "content/common/renderer_host.mojom.h" |
jam | c912ca3 | 2016-02-24 20:17:31 | [diff] [blame] | 42 | #include "content/common/storage_partition_service.mojom.h" |
mmenke | 680c214 | 2017-07-05 19:08:56 | [diff] [blame] | 43 | #include "content/public/common/url_loader_factory.mojom.h" |
[email protected] | 52647690 | 2011-10-06 20:34:06 | [diff] [blame] | 44 | #include "content/public/renderer/render_thread.h" |
Yuzhu Shen | fe5f3a5 | 2018-01-11 21:24:13 | [diff] [blame^] | 45 | #include "content/public/renderer/url_loader_throttle_provider.h" |
danakj | 6e3bf801 | 2014-12-16 18:27:53 | [diff] [blame] | 46 | #include "content/renderer/gpu/compositor_dependencies.h" |
danakj | 83066a3 | 2016-06-21 02:34:49 | [diff] [blame] | 47 | #include "content/renderer/layout_test_dependencies.h" |
maxmorin | 017ba8c6 | 2017-06-02 10:23:09 | [diff] [blame] | 48 | #include "content/renderer/media/audio_ipc_factory.h" |
penghuang | 346a46f9 | 2016-03-31 21:37:52 | [diff] [blame] | 49 | #include "gpu/ipc/client/gpu_channel_host.h" |
Antoine Labour | e55c9ef8 | 2017-11-10 18:51:23 | [diff] [blame] | 50 | #include "ipc/ipc_sync_channel.h" |
Brett Wilson | 0748bf41 | 2016-11-22 17:55:46 | [diff] [blame] | 51 | #include "media/media_features.h" |
rockot | 067ca55f | 2016-09-30 22:00:15 | [diff] [blame] | 52 | #include "mojo/public/cpp/bindings/associated_binding.h" |
blundell | c00adf44 | 2016-09-16 10:43:41 | [diff] [blame] | 53 | #include "mojo/public/cpp/bindings/binding.h" |
jcivelli | 315d17f | 2016-11-29 16:15:05 | [diff] [blame] | 54 | #include "mojo/public/cpp/bindings/thread_safe_interface_ptr.h" |
[email protected] | d7ff5fb | 2014-05-29 19:50:25 | [diff] [blame] | 55 | #include "net/base/network_change_notifier.h" |
tbansal | b612c5d | 2017-05-25 18:53:06 | [diff] [blame] | 56 | #include "net/nqe/effective_connection_type.h" |
Ben Goodger | 21ada1e | 2017-07-19 14:53:01 | [diff] [blame] | 57 | #include "services/service_manager/public/cpp/bind_source_info.h" |
Ken Rockot | 510c597 | 2017-12-05 16:37:04 | [diff] [blame] | 58 | #include "services/service_manager/public/cpp/binder_registry.h" |
danakj | ab9ef4d | 2017-10-31 23:38:33 | [diff] [blame] | 59 | #include "services/viz/public/interfaces/compositing/compositing_mode_watcher.mojom.h" |
[email protected] | d7ff5fb | 2014-05-29 19:50:25 | [diff] [blame] | 60 | #include "third_party/WebKit/public/platform/WebConnectionType.h" |
skyostil | 529caa29 | 2016-08-10 17:44:51 | [diff] [blame] | 61 | #include "third_party/WebKit/public/platform/scheduler/renderer/renderer_scheduler.h" |
tasak | b46626a | 2016-10-18 05:54:44 | [diff] [blame] | 62 | #include "third_party/WebKit/public/web/WebMemoryStatistics.h" |
[email protected] | 08397d5 | 2011-02-05 01:53:38 | [diff] [blame] | 63 | #include "ui/gfx/native_widget_types.h" |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 64 | |
[email protected] | 291857a | 2014-01-23 17:49:11 | [diff] [blame] | 65 | #if defined(OS_MACOSX) |
Joel Hockey | 473bc63 | 2017-06-16 02:17:24 | [diff] [blame] | 66 | #include "third_party/WebKit/public/platform/mac/WebScrollbarTheme.h" |
[email protected] | 291857a | 2014-01-23 17:49:11 | [diff] [blame] | 67 | #endif |
| 68 | |
[email protected] | 39008c0 | 2009-02-11 23:59:25 | [diff] [blame] | 69 | class SkBitmap; |
[email protected] | 46f36a49 | 2010-07-28 19:36:41 | [diff] [blame] | 70 | |
[email protected] | 180ef24 | 2013-11-07 06:50:46 | [diff] [blame] | 71 | namespace blink { |
skyostil | 529caa29 | 2016-08-10 17:44:51 | [diff] [blame] | 72 | namespace scheduler { |
| 73 | class WebThreadBase; |
| 74 | } |
[email protected] | d8cd837 | 2012-03-09 10:49:51 | [diff] [blame] | 75 | class WebMediaStreamCenter; |
| 76 | class WebMediaStreamCenterClient; |
[email protected] | b7c7bcf | 2009-10-03 07:07:34 | [diff] [blame] | 77 | } |
| 78 | |
[email protected] | 64ffa044 | 2011-10-03 22:08:36 | [diff] [blame] | 79 | namespace base { |
skyostil | 457b0a1 | 2014-09-09 10:12:07 | [diff] [blame] | 80 | class SingleThreadTaskRunner; |
[email protected] | 64ffa044 | 2011-10-03 22:08:36 | [diff] [blame] | 81 | class Thread; |
| 82 | } |
| 83 | |
[email protected] | c29b7ff | 2013-03-06 03:51:04 | [diff] [blame] | 84 | namespace cc { |
jbriance | ed97502 | 2016-11-04 09:14:25 | [diff] [blame] | 85 | class BeginFrameSource; |
danakj | c7afae5 | 2017-06-20 21:12:41 | [diff] [blame] | 86 | class LayerTreeFrameSink; |
samans | 09812d3 | 2017-03-27 19:51:50 | [diff] [blame] | 87 | class SyntheticBeginFrameSource; |
reveman | 34b7a152 | 2015-03-23 20:27:47 | [diff] [blame] | 88 | class TaskGraphRunner; |
[email protected] | c29b7ff | 2013-03-06 03:51:04 | [diff] [blame] | 89 | } |
| 90 | |
juncai | 2f298a8 | 2017-04-18 03:51:39 | [diff] [blame] | 91 | namespace device { |
| 92 | class Gamepads; |
| 93 | } |
| 94 | |
penghuang | 342762b | 2016-12-02 21:04:58 | [diff] [blame] | 95 | namespace discardable_memory { |
| 96 | class ClientDiscardableSharedMemoryManager; |
| 97 | } |
| 98 | |
penghuang | 346a46f9 | 2016-03-31 21:37:52 | [diff] [blame] | 99 | namespace gpu { |
| 100 | class GpuChannelHost; |
| 101 | } |
| 102 | |
[email protected] | 1842fe2 | 2012-08-13 23:24:35 | [diff] [blame] | 103 | namespace IPC { |
[email protected] | 7412204 | 2014-04-25 00:07:30 | [diff] [blame] | 104 | class MessageFilter; |
[email protected] | 1842fe2 | 2012-08-13 23:24:35 | [diff] [blame] | 105 | } |
| 106 | |
[email protected] | 563d665f | 2013-02-01 04:42:39 | [diff] [blame] | 107 | namespace media { |
[email protected] | 2329bfc7 | 2014-02-28 02:03:21 | [diff] [blame] | 108 | class GpuVideoAcceleratorFactories; |
[email protected] | 563d665f | 2013-02-01 04:42:39 | [diff] [blame] | 109 | } |
| 110 | |
sadrul | 9e0bb1d | 2016-08-04 20:18:39 | [diff] [blame] | 111 | namespace ui { |
sadrul | 85cc5d8 | 2016-12-20 03:37:41 | [diff] [blame] | 112 | class ContextProviderCommandBuffer; |
sadrul | 04cfa89 | 2016-12-09 17:53:49 | [diff] [blame] | 113 | class Gpu; |
sadrul | 9e0bb1d | 2016-08-04 20:18:39 | [diff] [blame] | 114 | } |
| 115 | |
[email protected] | e9ff79c | 2012-10-19 21:31:26 | [diff] [blame] | 116 | namespace v8 { |
| 117 | class Extension; |
| 118 | } |
| 119 | |
danakj | 9242985 | 2017-06-29 00:19:03 | [diff] [blame] | 120 | namespace viz { |
Fady Samuel | c645ffe | 2017-07-24 17:28:20 | [diff] [blame] | 121 | class BeginFrameSource; |
danakj | 9242985 | 2017-06-29 00:19:03 | [diff] [blame] | 122 | class ClientSharedBitmapManager; |
Victor Miura | ff648861 | 2017-12-21 04:16:15 | [diff] [blame] | 123 | class RasterContextProvider; |
Fady Samuel | c645ffe | 2017-07-24 17:28:20 | [diff] [blame] | 124 | class SyntheticBeginFrameSource; |
danakj | 9242985 | 2017-06-29 00:19:03 | [diff] [blame] | 125 | } |
| 126 | |
[email protected] | 64ffa044 | 2011-10-03 22:08:36 | [diff] [blame] | 127 | namespace content { |
[email protected] | e9ff79c | 2012-10-19 21:31:26 | [diff] [blame] | 128 | |
[email protected] | eb39819 | 2012-10-22 20:16:19 | [diff] [blame] | 129 | class AppCacheDispatcher; |
[email protected] | da9f30a | 2014-06-18 19:39:04 | [diff] [blame] | 130 | class AecDumpMessageFilter; |
[email protected] | 9a292e2 | 2012-10-22 15:19:31 | [diff] [blame] | 131 | class AudioInputMessageFilter; |
| 132 | class AudioMessageFilter; |
[email protected] | 3958e97 | 2012-07-17 00:25:41 | [diff] [blame] | 133 | class AudioRendererMixerManager; |
dmurph | 1fb9848 | 2016-03-30 21:14:26 | [diff] [blame] | 134 | class BlobMessageFilter; |
fsamuel | 6c1dfeb | 2014-12-18 19:21:33 | [diff] [blame] | 135 | class BrowserPluginManager; |
jsbell | 279efb4 | 2015-03-31 17:02:46 | [diff] [blame] | 136 | class CacheStorageDispatcher; |
John Abd-El-Malek | e1d4de3 | 2017-10-21 16:14:29 | [diff] [blame] | 137 | class CategorizedWorkerPool; |
simonhong | a7e3ac4 | 2014-11-11 20:50:22 | [diff] [blame] | 138 | class CompositorForwardingMessageFilter; |
[email protected] | e9ff79c | 2012-10-19 21:31:26 | [diff] [blame] | 139 | class DomStorageDispatcher; |
John Abd-El-Malek | dcf1d137 | 2017-10-22 06:39:41 | [diff] [blame] | 140 | class FileSystemDispatcher; |
danakj | 83066a3 | 2016-06-21 02:34:49 | [diff] [blame] | 141 | class FrameSwapMessageQueue; |
John Abd-El-Malek | e1d4de3 | 2017-10-21 16:14:29 | [diff] [blame] | 142 | class GpuVideoAcceleratorFactoriesImpl; |
[email protected] | eb39819 | 2012-10-22 20:16:19 | [diff] [blame] | 143 | class IndexedDBDispatcher; |
[email protected] | ea5f70a | 2013-03-07 12:30:36 | [diff] [blame] | 144 | class InputHandlerManager; |
[email protected] | 6e068ea | 2014-02-04 07:05:47 | [diff] [blame] | 145 | class MidiMessageFilter; |
John Abd-El-Malek | f9f86c1 | 2017-10-21 07:22:23 | [diff] [blame] | 146 | class NotificationDispatcher; |
[email protected] | 4761cf1 | 2012-09-12 10:37:55 | [diff] [blame] | 147 | class P2PSocketDispatcher; |
jsbell | abadb9b | 2015-03-23 21:03:44 | [diff] [blame] | 148 | class PeerConnectionDependencyFactory; |
[email protected] | af08997 | 2013-01-10 04:04:40 | [diff] [blame] | 149 | class PeerConnectionTracker; |
John Abd-El-Malek | f75a319 | 2017-10-22 14:23:20 | [diff] [blame] | 150 | class QuotaDispatcher; |
tyoshino | 832a58a | 2016-04-18 08:14:08 | [diff] [blame] | 151 | class RenderThreadObserver; |
tfarina | 556a723 | 2014-10-05 01:02:09 | [diff] [blame] | 152 | class RendererBlinkPlatformImpl; |
John Abd-El-Malek | 6b56ef71 | 2017-10-21 22:52:46 | [diff] [blame] | 153 | class ResourceDispatcher; |
John Abd-El-Malek | e1d4de3 | 2017-10-21 16:14:29 | [diff] [blame] | 154 | class ServiceWorkerMessageFilter; |
[email protected] | 9a292e2 | 2012-10-22 15:19:31 | [diff] [blame] | 155 | class VideoCaptureImplManager; |
[email protected] | cb25aa1 | 2012-08-07 19:13:43 | [diff] [blame] | 156 | |
boliu | bee541f4 | 2015-11-05 00:52:53 | [diff] [blame] | 157 | #if defined(OS_ANDROID) |
siva.gunturi | 5d4feb05 | 2015-11-15 16:15:31 | [diff] [blame] | 158 | class StreamTextureFactory; |
boliu | bee541f4 | 2015-11-05 00:52:53 | [diff] [blame] | 159 | class SynchronousCompositorFilter; |
| 160 | #endif |
| 161 | |
jam | 8a021512a | 2015-02-03 18:16:08 | [diff] [blame] | 162 | #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] | f1a29a0 | 2011-10-06 23:08:44 | [diff] [blame] | 168 | // The RenderThreadImpl class represents a background thread where RenderView |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 169 | // 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] | 770005b | 2012-04-16 15:58:13 | [diff] [blame] | 172 | // process (i.e., their corresponding WebContentsImpl). |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 173 | // |
| 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. |
danakj | 6e3bf801 | 2014-12-16 18:27:53 | [diff] [blame] | 177 | class CONTENT_EXPORT RenderThreadImpl |
| 178 | : public RenderThread, |
jam | 8a021512a | 2015-02-03 18:16:08 | [diff] [blame] | 179 | public ChildThreadImpl, |
skyostil | 529caa29 | 2016-08-10 17:44:51 | [diff] [blame] | 180 | public blink::scheduler::RendererScheduler::RAILModeObserver, |
bashi | a626404 | 2016-09-15 04:49:51 | [diff] [blame] | 181 | public ChildMemoryCoordinatorDelegate, |
hajimehoshi | 7bb3958 | 2016-10-12 04:30:57 | [diff] [blame] | 182 | public base::MemoryCoordinatorClient, |
Nico Weber | 43ddd7a3 | 2017-08-15 19:19:27 | [diff] [blame] | 183 | public mojom::Renderer, |
danakj | ab9ef4d | 2017-10-31 23:38:33 | [diff] [blame] | 184 | public viz::mojom::CompositingModeWatcher, |
Nico Weber | 43ddd7a3 | 2017-08-15 19:19:27 | [diff] [blame] | 185 | public CompositorDependencies { |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 186 | public: |
leon.han | 2c0f9f1 | 2015-07-11 02:01:19 | [diff] [blame] | 187 | static RenderThreadImpl* Create(const InProcessChildThreadParams& params); |
| 188 | static RenderThreadImpl* Create( |
dcheng | cedca561 | 2016-04-09 01:40:15 | [diff] [blame] | 189 | std::unique_ptr<base::MessageLoop> main_message_loop, |
skyostil | 529caa29 | 2016-08-10 17:44:51 | [diff] [blame] | 190 | std::unique_ptr<blink::scheduler::RendererScheduler> renderer_scheduler); |
[email protected] | f1a29a0 | 2011-10-06 23:08:44 | [diff] [blame] | 191 | static RenderThreadImpl* current(); |
rockot | 5c478a7 | 2016-09-28 23:14:18 | [diff] [blame] | 192 | static mojom::RenderMessageFilter* current_render_message_filter(); |
olegmax | 045f7fb1 | 2017-05-19 07:58:55 | [diff] [blame] | 193 | static RendererBlinkPlatformImpl* current_blink_platform_impl(); |
rockot | 5c478a7 | 2016-09-28 23:14:18 | [diff] [blame] | 194 | |
| 195 | static void SetRenderMessageFilterForTesting( |
| 196 | mojom::RenderMessageFilter* render_message_filter); |
olegmax | 045f7fb1 | 2017-05-19 07:58:55 | [diff] [blame] | 197 | static void SetRendererBlinkPlatformImplForTesting( |
| 198 | RendererBlinkPlatformImpl* blink_platform_impl); |
[email protected] | 52647690 | 2011-10-06 20:34:06 | [diff] [blame] | 199 | |
John Abd-El-Malek | d488264 | 2017-12-04 21:45:19 | [diff] [blame] | 200 | // Returns the task runner for the main thread where the RenderThread lives. |
| 201 | static scoped_refptr<base::SingleThreadTaskRunner> GetMainTaskRunner(); |
| 202 | |
dcheng | 6d18e40 | 2014-10-21 12:32:52 | [diff] [blame] | 203 | ~RenderThreadImpl() override; |
| 204 | void Shutdown() override; |
haraken | bbfdd9f0 | 2017-01-12 07:14:04 | [diff] [blame] | 205 | bool ShouldBeDestroyed() override; |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 206 | |
[email protected] | 58436a1 | 2012-03-21 17:10:26 | [diff] [blame] | 207 | // 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] | e9ff79c | 2012-10-19 21:31:26 | [diff] [blame] | 211 | // RenderThread implementation: |
dcheng | 6d18e40 | 2014-10-21 12:32:52 | [diff] [blame] | 212 | bool Send(IPC::Message* msg) override; |
dcheng | 6d18e40 | 2014-10-21 12:32:52 | [diff] [blame] | 213 | IPC::SyncChannel* GetChannel() override; |
| 214 | std::string GetLocale() override; |
| 215 | IPC::SyncMessageFilter* GetSyncMessageFilter() override; |
avi | 1023d01 | 2015-12-25 02:39:14 | [diff] [blame] | 216 | void AddRoute(int32_t routing_id, IPC::Listener* listener) override; |
| 217 | void RemoveRoute(int32_t routing_id) override; |
dcheng | 6d18e40 | 2014-10-21 12:32:52 | [diff] [blame] | 218 | int GenerateRoutingID() override; |
| 219 | void AddFilter(IPC::MessageFilter* filter) override; |
| 220 | void RemoveFilter(IPC::MessageFilter* filter) override; |
tyoshino | 832a58a | 2016-04-18 08:14:08 | [diff] [blame] | 221 | void AddObserver(RenderThreadObserver* observer) override; |
| 222 | void RemoveObserver(RenderThreadObserver* observer) override; |
dcheng | 6d18e40 | 2014-10-21 12:32:52 | [diff] [blame] | 223 | void SetResourceDispatcherDelegate( |
mohan.reddy | ee0b42a | 2014-10-08 04:53:14 | [diff] [blame] | 224 | ResourceDispatcherDelegate* delegate) override; |
dcheng | cedca561 | 2016-04-09 01:40:15 | [diff] [blame] | 225 | std::unique_ptr<base::SharedMemory> HostAllocateSharedMemoryBuffer( |
mohan.reddy | ee0b42a | 2014-10-08 04:53:14 | [diff] [blame] | 226 | size_t buffer_size) override; |
Fady Samuel | 4b5f986 | 2017-07-11 05:27:20 | [diff] [blame] | 227 | viz::SharedBitmapManager* GetSharedBitmapManager() override; |
dcheng | 6d18e40 | 2014-10-21 12:32:52 | [diff] [blame] | 228 | void RegisterExtension(v8::Extension* extension) override; |
avi | 1023d01 | 2015-12-25 02:39:14 | [diff] [blame] | 229 | void ScheduleIdleHandler(int64_t initial_delay_ms) override; |
dcheng | 6d18e40 | 2014-10-21 12:32:52 | [diff] [blame] | 230 | void IdleHandler() override; |
avi | 1023d01 | 2015-12-25 02:39:14 | [diff] [blame] | 231 | int64_t GetIdleNotificationDelayInMs() const override; |
dcheng | 6d18e40 | 2014-10-21 12:32:52 | [diff] [blame] | 232 | void SetIdleNotificationDelayInMs( |
avi | 1023d01 | 2015-12-25 02:39:14 | [diff] [blame] | 233 | int64_t idle_notification_delay_in_ms) override; |
dcheng | 6d18e40 | 2014-10-21 12:32:52 | [diff] [blame] | 234 | int PostTaskToAllWebWorkers(const base::Closure& closure) override; |
| 235 | bool ResolveProxy(const GURL& url, std::string* proxy_list) override; |
| 236 | base::WaitableEvent* GetShutdownEvent() override; |
staraz | 067f5824 | 2016-11-07 21:06:41 | [diff] [blame] | 237 | int32_t GetClientId() override; |
Karan Bhatia | c89897f | 2017-08-10 01:06:40 | [diff] [blame] | 238 | void SetRendererProcessType( |
| 239 | blink::scheduler::RendererProcessType type) override; |
[email protected] | 1223d6ef | 2011-03-28 16:47:50 | [diff] [blame] | 240 | |
rockot | 067ca55f | 2016-09-30 22:00:15 | [diff] [blame] | 241 | // IPC::Listener implementation via ChildThreadImpl: |
John Abd-El-Malek | 6b56ef71 | 2017-10-21 22:52:46 | [diff] [blame] | 242 | bool OnMessageReceived(const IPC::Message& msg) override; |
rockot | 067ca55f | 2016-09-30 22:00:15 | [diff] [blame] | 243 | void OnAssociatedInterfaceRequest( |
| 244 | const std::string& name, |
| 245 | mojo::ScopedInterfaceEndpointHandle handle) override; |
| 246 | |
weili | fabbf757 | 2017-05-22 19:05:16 | [diff] [blame] | 247 | // ChildThread implementation via ChildThreadImpl: |
| 248 | scoped_refptr<base::SingleThreadTaskRunner> GetIOTaskRunner() override; |
| 249 | |
danakj | 6e3bf801 | 2014-12-16 18:27:53 | [diff] [blame] | 250 | // CompositorDependencies implementation. |
danakj | 6e3bf801 | 2014-12-16 18:27:53 | [diff] [blame] | 251 | bool IsGpuRasterizationForced() override; |
senorblanco | b60ba95 | 2015-01-27 19:12:36 | [diff] [blame] | 252 | int GetGpuRasterizationMSAASampleCount() override; |
danakj | 6e3bf801 | 2014-12-16 18:27:53 | [diff] [blame] | 253 | bool IsLcdTextEnabled() override; |
| 254 | bool IsDistanceFieldTextEnabled() override; |
| 255 | bool IsZeroCopyEnabled() override; |
ericrk | 1d17f75 | 2015-10-20 03:03:07 | [diff] [blame] | 256 | bool IsPartialRasterEnabled() override; |
ccameron | c7fcd13 | 2015-11-03 20:14:31 | [diff] [blame] | 257 | bool IsGpuMemoryBufferCompositorResourcesEnabled() override; |
ccameron | a764475 | 2014-12-30 01:16:31 | [diff] [blame] | 258 | bool IsElasticOverscrollEnabled() override; |
danakj | 6e3bf801 | 2014-12-16 18:27:53 | [diff] [blame] | 259 | scoped_refptr<base::SingleThreadTaskRunner> |
| 260 | GetCompositorMainThreadTaskRunner() override; |
| 261 | scoped_refptr<base::SingleThreadTaskRunner> |
| 262 | GetCompositorImplThreadTaskRunner() override; |
skyostil | 529caa29 | 2016-08-10 17:44:51 | [diff] [blame] | 263 | blink::scheduler::RendererScheduler* GetRendererScheduler() override; |
reveman | 34b7a152 | 2015-03-23 20:27:47 | [diff] [blame] | 264 | cc::TaskGraphRunner* GetTaskGraphRunner() override; |
loyso | 65c93c60 | 2015-08-11 05:15:57 | [diff] [blame] | 265 | bool IsThreadedAnimationEnabled() override; |
wjmaclean | 1d97062 | 2017-01-21 22:28:24 | [diff] [blame] | 266 | bool IsScrollAnimatorEnabled() override; |
Khushal | 3e96e66 | 2017-10-30 23:16:50 | [diff] [blame] | 267 | std::unique_ptr<cc::UkmRecorderFactory> CreateUkmRecorderFactory() override; |
danakj | 6e3bf801 | 2014-12-16 18:27:53 | [diff] [blame] | 268 | |
skyostil | 529caa29 | 2016-08-10 17:44:51 | [diff] [blame] | 269 | // blink::scheduler::RendererScheduler::RAILModeObserver implementation. |
skyostil | a37c2a7 | 2016-06-29 17:30:07 | [diff] [blame] | 270 | void OnRAILModeChanged(v8::RAILMode rail_mode) override; |
| 271 | |
danakj | ab9ef4d | 2017-10-31 23:38:33 | [diff] [blame] | 272 | // 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] | b3e83de | 2012-02-07 03:33:28 | [diff] [blame] | 280 | // 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 Liu | d1ef1c3 | 2017-12-08 06:15:50 | [diff] [blame] | 283 | // time this routine returns. |
| 284 | scoped_refptr<gpu::GpuChannelHost> EstablishGpuChannelSync(); |
[email protected] | b3e83de | 2012-02-07 03:33:28 | [diff] [blame] | 285 | |
piman | c44437a2 | 2016-10-29 00:09:22 | [diff] [blame] | 286 | gpu::GpuMemoryBufferManager* GetGpuMemoryBufferManager(); |
| 287 | |
danakj | c7afae5 | 2017-06-20 21:12:41 | [diff] [blame] | 288 | using LayerTreeFrameSinkCallback = |
| 289 | base::Callback<void(std::unique_ptr<cc::LayerTreeFrameSink>)>; |
| 290 | void RequestNewLayerTreeFrameSink( |
danakj | 83066a3 | 2016-06-21 02:34:49 | [diff] [blame] | 291 | int routing_id, |
| 292 | scoped_refptr<FrameSwapMessageQueue> frame_swap_message_queue, |
fsamuel | cf3002e | 2017-03-20 23:13:47 | [diff] [blame] | 293 | const GURL& url, |
danakj | c7afae5 | 2017-06-20 21:12:41 | [diff] [blame] | 294 | const LayerTreeFrameSinkCallback& callback); |
danakj | 83066a3 | 2016-06-21 02:34:49 | [diff] [blame] | 295 | |
Sam McNally | 52e5028 | 2017-11-29 00:54:02 | [diff] [blame] | 296 | blink::AssociatedInterfaceRegistry* GetAssociatedInterfaceRegistry(); |
rockot | 067ca55f | 2016-09-30 22:00:15 | [diff] [blame] | 297 | |
jbroman | 6ccbc7d47 | 2016-07-27 04:45:41 | [diff] [blame] | 298 | std::unique_ptr<cc::SwapPromise> RequestCopyOfOutputForLayoutTest( |
| 299 | int32_t routing_id, |
Fady Samuel | dfecb7d | 2017-07-26 11:41:04 | [diff] [blame] | 300 | std::unique_ptr<viz::CopyOutputRequest> request); |
jbroman | 6ccbc7d47 | 2016-07-27 04:45:41 | [diff] [blame] | 301 | |
[email protected] | 70dee7e | 2013-05-29 18:28:30 | [diff] [blame] | 302 | // 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. |
danakj | 83066a3 | 2016-06-21 02:34:49 | [diff] [blame] | 305 | 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] | ac7f5a0 | 2013-03-16 16:14:41 | [diff] [blame] | 309 | } |
| 310 | |
penghuang | 342762b | 2016-12-02 21:04:58 | [diff] [blame] | 311 | discardable_memory::ClientDiscardableSharedMemoryManager* |
| 312 | GetDiscardableSharedMemoryManagerForTest() { |
| 313 | return discardable_shared_memory_manager_.get(); |
| 314 | } |
| 315 | |
tfarina | 556a723 | 2014-10-05 01:02:09 | [diff] [blame] | 316 | RendererBlinkPlatformImpl* blink_platform_impl() const { |
| 317 | DCHECK(blink_platform_impl_); |
| 318 | return blink_platform_impl_.get(); |
[email protected] | 078780b | 2014-06-20 16:57:06 | [diff] [blame] | 319 | } |
| 320 | |
simonhong | a7e3ac4 | 2014-11-11 20:50:22 | [diff] [blame] | 321 | CompositorForwardingMessageFilter* compositor_message_filter() const { |
| 322 | return compositor_message_filter_.get(); |
[email protected] | 1842fe2 | 2012-08-13 23:24:35 | [diff] [blame] | 323 | } |
| 324 | |
[email protected] | ea5f70a | 2013-03-07 12:30:36 | [diff] [blame] | 325 | InputHandlerManager* input_handler_manager() const { |
| 326 | return input_handler_manager_.get(); |
| 327 | } |
| 328 | |
danakj | 6e3bf801 | 2014-12-16 18:27:53 | [diff] [blame] | 329 | // Will be null if threaded compositing has not been enabled. |
skyostil | 2d3b5bd | 2015-05-27 15:40:59 | [diff] [blame] | 330 | scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner() const { |
| 331 | return compositor_task_runner_; |
[email protected] | a9fb30aa | 2011-10-06 06:58:46 | [diff] [blame] | 332 | } |
| 333 | |
[email protected] | f430b571 | 2009-08-21 21:46:31 | [diff] [blame] | 334 | AppCacheDispatcher* appcache_dispatcher() const { |
| 335 | return appcache_dispatcher_.get(); |
| 336 | } |
| 337 | |
[email protected] | 19b4951 | 2012-05-30 19:22:09 | [diff] [blame] | 338 | DomStorageDispatcher* dom_storage_dispatcher() const { |
| 339 | return dom_storage_dispatcher_.get(); |
| 340 | } |
| 341 | |
[email protected] | f7eb0a39 | 2011-07-12 10:19:51 | [diff] [blame] | 342 | AudioInputMessageFilter* audio_input_message_filter() { |
| 343 | return audio_input_message_filter_.get(); |
| 344 | } |
| 345 | |
John Abd-El-Malek | dcf1d137 | 2017-10-22 06:39:41 | [diff] [blame] | 346 | FileSystemDispatcher* file_system_dispatcher() const { |
| 347 | return file_system_dispatcher_.get(); |
| 348 | } |
| 349 | |
[email protected] | 6e068ea | 2014-02-04 07:05:47 | [diff] [blame] | 350 | MidiMessageFilter* midi_message_filter() { |
[email protected] | a987515 | 2013-06-22 04:03:03 | [diff] [blame] | 351 | return midi_message_filter_.get(); |
| 352 | } |
[email protected] | 6ee10bd | 2012-09-13 09:01:53 | [diff] [blame] | 353 | |
John Abd-El-Malek | f75a319 | 2017-10-22 14:23:20 | [diff] [blame] | 354 | QuotaDispatcher* quota_dispatcher() const { |
| 355 | return quota_dispatcher_.get(); |
| 356 | } |
| 357 | |
John Abd-El-Malek | 6b56ef71 | 2017-10-21 22:52:46 | [diff] [blame] | 358 | ResourceDispatcher* resource_dispatcher() const { |
| 359 | return resource_dispatcher_.get(); |
| 360 | } |
| 361 | |
Yuzhu Shen | fe5f3a5 | 2018-01-11 21:24:13 | [diff] [blame^] | 362 | URLLoaderThrottleProvider* url_loader_throttle_provider() const { |
| 363 | return url_loader_throttle_provider_.get(); |
| 364 | } |
| 365 | |
[email protected] | 6ca6a08 | 2013-09-22 20:10:05 | [diff] [blame] | 366 | #if defined(OS_ANDROID) |
boliu | bee541f4 | 2015-11-05 00:52:53 | [diff] [blame] | 367 | SynchronousCompositorFilter* sync_compositor_message_filter() { |
| 368 | return sync_compositor_message_filter_.get(); |
| 369 | } |
siva.gunturi | 5d4feb05 | 2015-11-15 16:15:31 | [diff] [blame] | 370 | |
| 371 | scoped_refptr<StreamTextureFactory> GetStreamTexureFactory(); |
boliu | f8753bf6 | 2016-02-11 20:09:42 | [diff] [blame] | 372 | bool EnableStreamTextureCopy(); |
[email protected] | 6ca6a08 | 2013-09-22 20:10:05 | [diff] [blame] | 373 | #endif |
| 374 | |
[email protected] | d8cd837 | 2012-03-09 10:49:51 | [diff] [blame] | 375 | // Creates the embedder implementation of WebMediaStreamCenter. |
| 376 | // The resulting object is owned by WebKit and deleted by WebKit at tear-down. |
altimin | eb6bd196 | 2017-05-03 14:52:38 | [diff] [blame] | 377 | std::unique_ptr<blink::WebMediaStreamCenter> CreateMediaStreamCenter( |
[email protected] | 180ef24 | 2013-11-07 06:50:46 | [diff] [blame] | 378 | blink::WebMediaStreamCenterClient* client); |
[email protected] | d8cd837 | 2012-03-09 10:49:51 | [diff] [blame] | 379 | |
fsamuel | 6c1dfeb | 2014-12-18 19:21:33 | [diff] [blame] | 380 | BrowserPluginManager* browser_plugin_manager() const { |
| 381 | return browser_plugin_manager_.get(); |
| 382 | } |
| 383 | |
Brett Wilson | 0748bf41 | 2016-11-22 17:55:46 | [diff] [blame] | 384 | #if BUILDFLAG(ENABLE_WEBRTC) |
[email protected] | 6ee10bd | 2012-09-13 09:01:53 | [diff] [blame] | 385 | // Returns a factory used for creating RTC PeerConnection objects. |
[email protected] | 0107d8a | 2014-05-16 10:20:34 | [diff] [blame] | 386 | PeerConnectionDependencyFactory* GetPeerConnectionDependencyFactory(); |
[email protected] | 6ee10bd | 2012-09-13 09:01:53 | [diff] [blame] | 387 | |
[email protected] | af08997 | 2013-01-10 04:04:40 | [diff] [blame] | 388 | PeerConnectionTracker* peer_connection_tracker() { |
| 389 | return peer_connection_tracker_.get(); |
| 390 | } |
| 391 | |
[email protected] | 4761cf1 | 2012-09-12 10:37:55 | [diff] [blame] | 392 | // Current P2PSocketDispatcher. Set to NULL if P2P API is disabled. |
[email protected] | e9ff79c | 2012-10-19 21:31:26 | [diff] [blame] | 393 | P2PSocketDispatcher* p2p_socket_dispatcher() { |
[email protected] | 4761cf1 | 2012-09-12 10:37:55 | [diff] [blame] | 394 | return p2p_socket_dispatcher_.get(); |
| 395 | } |
[email protected] | 22fe91d | 2014-08-12 17:07:12 | [diff] [blame] | 396 | #endif |
[email protected] | 4761cf1 | 2012-09-12 10:37:55 | [diff] [blame] | 397 | |
[email protected] | 80b161a | 2011-06-27 17:42:11 | [diff] [blame] | 398 | VideoCaptureImplManager* video_capture_impl_manager() const { |
| 399 | return vc_manager_.get(); |
| 400 | } |
| 401 | |
danakj | 9242985 | 2017-06-29 00:19:03 | [diff] [blame] | 402 | viz::ClientSharedBitmapManager* shared_bitmap_manager() const { |
jcivelli | 0f21bd5 | 2016-12-07 21:21:33 | [diff] [blame] | 403 | DCHECK(shared_bitmap_manager_); |
| 404 | return shared_bitmap_manager_.get(); |
| 405 | } |
| 406 | |
John Abd-El-Malek | f9f86c1 | 2017-10-21 07:22:23 | [diff] [blame] | 407 | NotificationDispatcher* notification_dispatcher() const { |
| 408 | return notification_dispatcher_.get(); |
| 409 | } |
| 410 | |
rockot | 1587e33 | 2016-07-27 17:44:14 | [diff] [blame] | 411 | mojom::RenderFrameMessageFilter* render_frame_message_filter(); |
rockot | e261d211 | 2016-09-21 22:22:23 | [diff] [blame] | 412 | mojom::RenderMessageFilter* render_message_filter(); |
rockot | 1587e33 | 2016-07-27 17:44:14 | [diff] [blame] | 413 | |
[email protected] | 6217d39 | 2010-03-25 22:08:35 | [diff] [blame] | 414 | // Get the GPU channel. Returns NULL if the channel is not established or |
| 415 | // has been lost. |
penghuang | 346a46f9 | 2016-03-31 21:37:52 | [diff] [blame] | 416 | gpu::GpuChannelHost* GetGpuChannel(); |
[email protected] | 6217d39 | 2010-03-25 22:08:35 | [diff] [blame] | 417 | |
skyostil | 2d3b5bd | 2015-05-27 15:40:59 | [diff] [blame] | 418 | // Returns a SingleThreadTaskRunner instance corresponding to the message loop |
[email protected] | c6a7b86 | 2010-08-20 22:19:38 | [diff] [blame] | 419 | // of the thread on which file operations should be run. Must be called |
| 420 | // on the renderer's main thread. |
Marijn Kruisselbrink | 8c27641 | 2017-07-29 06:11:21 | [diff] [blame] | 421 | scoped_refptr<base::TaskRunner> GetFileThreadTaskRunner(); |
[email protected] | c6a7b86 | 2010-08-20 22:19:38 | [diff] [blame] | 422 | |
acolwell | b403494 | 2014-08-28 15:42:43 | [diff] [blame] | 423 | // Returns a SingleThreadTaskRunner instance corresponding to the message loop |
[email protected] | c1330c8 | 2013-06-06 02:23:25 | [diff] [blame] | 424 | // of the thread on which media operations should be run. Must be called |
| 425 | // on the renderer's main thread. |
acolwell | b403494 | 2014-08-28 15:42:43 | [diff] [blame] | 426 | scoped_refptr<base::SingleThreadTaskRunner> GetMediaThreadTaskRunner(); |
[email protected] | c1330c8 | 2013-06-06 02:23:25 | [diff] [blame] | 427 | |
dcastagna | 4517a18 | 2015-08-05 19:51:03 | [diff] [blame] | 428 | // A TaskRunner instance that runs tasks on the raster worker pool. |
| 429 | base::TaskRunner* GetWorkerTaskRunner(); |
dcastagna | b880e8f | 2015-06-30 20:16:06 | [diff] [blame] | 430 | |
danakj | 0b4b94e3 | 2016-05-10 22:33:01 | [diff] [blame] | 431 | // Returns a worker context provider that will be bound on the compositor |
| 432 | // thread. |
Victor Miura | ff648861 | 2017-12-21 04:16:15 | [diff] [blame] | 433 | scoped_refptr<viz::RasterContextProvider> |
danakj | 0b4b94e3 | 2016-05-10 22:33:01 | [diff] [blame] | 434 | SharedCompositorWorkerContextProvider(); |
reveman | d180dfc3 | 2015-09-24 00:19:43 | [diff] [blame] | 435 | |
[email protected] | 1784b2f | 2011-11-24 10:53:48 | [diff] [blame] | 436 | // 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 | |
dcastagna | 7f45dada | 2015-10-19 20:17:35 | [diff] [blame] | 441 | media::GpuVideoAcceleratorFactories* GetGpuFactories(); |
[email protected] | 3bb8bb3 | 2013-07-11 13:13:03 | [diff] [blame] | 442 | |
sadrul | 85cc5d8 | 2016-12-20 03:37:41 | [diff] [blame] | 443 | scoped_refptr<ui::ContextProviderCommandBuffer> |
| 444 | SharedMainThreadContextProvider(); |
[email protected] | c29b7ff | 2013-03-06 03:51:04 | [diff] [blame] | 445 | |
[email protected] | 3958e97 | 2012-07-17 00:25:41 | [diff] [blame] | 446 | // AudioRendererMixerManager instance which manages renderer side mixer |
| 447 | // instances shared based on configured audio parameters. Lazily created on |
| 448 | // first call. |
[email protected] | e9ff79c | 2012-10-19 21:31:26 | [diff] [blame] | 449 | AudioRendererMixerManager* GetAudioRendererMixerManager(); |
[email protected] | 3958e97 | 2012-07-17 00:25:41 | [diff] [blame] | 450 | |
[email protected] | feb3237 | 2012-11-21 01:14:56 | [diff] [blame] | 451 | #if defined(OS_WIN) |
[email protected] | fcf75d4 | 2013-12-03 20:11:26 | [diff] [blame] | 452 | void PreCacheFontCharacters(const LOGFONT& log_font, |
| 453 | const base::string16& str); |
[email protected] | feb3237 | 2012-11-21 01:14:56 | [diff] [blame] | 454 | #endif |
| 455 | |
[email protected] | b2d9876 | 2012-09-03 17:04:06 | [diff] [blame] | 456 | // 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: |
hablich | d6a4f12 | 2015-10-28 11:34:49 | [diff] [blame] | 479 | FRIEND_TEST_ALL_PREFIXES(RenderThreadImplUnittest, |
| 480 | IdentifyAlexaTop10NonGoogleSite); |
[email protected] | b2d9876 | 2012-09-03 17:04:06 | [diff] [blame] | 481 | friend class RenderThreadImplUnittest; |
| 482 | |
hablich | d6a4f12 | 2015-10-28 11:34:49 | [diff] [blame] | 483 | // 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] | b2d9876 | 2012-09-03 17:04:06 | [diff] [blame] | 489 | // 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] | ca998e5e | 2013-08-06 14:59:09 | [diff] [blame] | 510 | // Retrieve current gamepad data. |
juncai | 2f298a8 | 2017-04-18 03:51:39 | [diff] [blame] | 511 | void SampleGamepads(device::Gamepads* data); |
[email protected] | ca998e5e | 2013-08-06 14:59:09 | [diff] [blame] | 512 | |
[email protected] | b2db927 | 2014-01-10 17:42:00 | [diff] [blame] | 513 | // 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(); |
rmcilroy | aa29605 | 2015-04-14 15:35:27 | [diff] [blame] | 516 | // 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] | b2db927 | 2014-01-10 17:42:00 | [diff] [blame] | 518 | void WidgetDestroyed(); |
| 519 | void WidgetHidden(); |
| 520 | void WidgetRestored(); |
| 521 | |
ben | f28ce88 | 2017-05-02 16:15:49 | [diff] [blame] | 522 | void RegisterPendingFrameCreate( |
| 523 | const service_manager::BindSourceInfo& source_info, |
| 524 | int routing_id, |
Balazs Engedy | ba034e7 | 2017-10-27 22:26:28 | [diff] [blame] | 525 | mojom::FrameRequest frame); |
rockot | f8fdd9b | 2015-12-16 22:22:35 | [diff] [blame] | 526 | |
leon.han | 06e5566 | 2016-03-26 17:19:42 | [diff] [blame] | 527 | mojom::StoragePartitionService* GetStoragePartitionService(); |
jam | 188f19f | 2017-06-07 03:56:24 | [diff] [blame] | 528 | mojom::RendererHost* GetRendererHost(); |
jam | c912ca3 | 2016-02-24 20:17:31 | [diff] [blame] | 529 | |
bashi | a626404 | 2016-09-15 04:49:51 | [diff] [blame] | 530 | // ChildMemoryCoordinatorDelegate implementation. |
bashi | c4b4afcb | 2016-08-23 06:37:52 | [diff] [blame] | 531 | void OnTrimMemoryImmediately() override; |
| 532 | |
keishi | 51ed0d5 | 2017-01-12 10:04:46 | [diff] [blame] | 533 | 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 | }; |
bashi | a0ba0d4 | 2017-04-03 08:11:06 | [diff] [blame] | 543 | bool GetRendererMemoryMetrics(RendererMemoryMetrics* memory_metrics) const; |
keishi | 51ed0d5 | 2017-01-12 10:04:46 | [diff] [blame] | 544 | |
Takashi SAKAMOTO | 870f626 | 2017-08-22 04:08:27 | [diff] [blame] | 545 | bool NeedsToRecordFirstActivePaint(int metric_type) const; |
tasak | b95dbb50c | 2017-02-08 18:07:50 | [diff] [blame] | 546 | |
Miguel Casas | 5e101805 | 2018-01-09 19:17:36 | [diff] [blame] | 547 | // Sets the current pipeline rendering color space. |
| 548 | void SetRenderingColorSpace(const gfx::ColorSpace& color_space); |
| 549 | |
alexclarke | 0bc36e8d3 | 2014-12-17 17:29:20 | [diff] [blame] | 550 | protected: |
jam | 75c4422 | 2016-03-23 05:34:24 | [diff] [blame] | 551 | RenderThreadImpl( |
| 552 | const InProcessChildThreadParams& params, |
skyostil | 529caa29 | 2016-08-10 17:44:51 | [diff] [blame] | 553 | std::unique_ptr<blink::scheduler::RendererScheduler> scheduler, |
rockot | 97a8683 | 2016-12-10 04:53:06 | [diff] [blame] | 554 | const scoped_refptr<base::SingleThreadTaskRunner>& resource_task_queue); |
skyostil | 529caa29 | 2016-08-10 17:44:51 | [diff] [blame] | 555 | RenderThreadImpl( |
| 556 | std::unique_ptr<base::MessageLoop> main_message_loop, |
| 557 | std::unique_ptr<blink::scheduler::RendererScheduler> scheduler); |
alexclarke | 0bc36e8d3 | 2014-12-17 17:29:20 | [diff] [blame] | 558 | |
[email protected] | 8930d47 | 2009-02-21 08:05:28 | [diff] [blame] | 559 | private: |
Nicholas Verne | 06de812 | 2017-11-16 04:47:38 | [diff] [blame] | 560 | void OnProcessFinalRelease() override; |
torne | 88b6645 | 2016-05-03 13:22:14 | [diff] [blame] | 561 | // IPC::Listener |
| 562 | void OnChannelError() override; |
| 563 | |
[email protected] | 57cf9788 | 2013-06-26 20:39:01 | [diff] [blame] | 564 | // ChildThread |
dcheng | 6d18e40 | 2014-10-21 12:32:52 | [diff] [blame] | 565 | bool OnControlMessageReceived(const IPC::Message& msg) override; |
liberato | 3aeeb2c | 2016-02-25 17:54:38 | [diff] [blame] | 566 | void RecordAction(const base::UserMetricsAction& action) override; |
| 567 | void RecordComputedAction(const std::string& action) override; |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 568 | |
sadrul | 5354659 | 2016-12-17 01:44:21 | [diff] [blame] | 569 | bool IsMainThread(); |
[email protected] | 57cf9788 | 2013-06-26 20:39:01 | [diff] [blame] | 570 | |
hajimehoshi | 7bb3958 | 2016-10-12 04:30:57 | [diff] [blame] | 571 | // base::MemoryCoordinatorClient implementation: |
| 572 | void OnMemoryStateChange(base::MemoryState state) override; |
bashi | 233f65e | 2017-02-09 08:36:03 | [diff] [blame] | 573 | void OnPurgeMemory() override; |
hajimehoshi | 7bb3958 | 2016-10-12 04:30:57 | [diff] [blame] | 574 | |
bashi | b9058f28 | 2017-03-30 01:55:24 | [diff] [blame] | 575 | void RecordPurgeMemory(RendererMemoryMetrics before); |
| 576 | |
hajimehoshi | 7bb3958 | 2016-10-12 04:30:57 | [diff] [blame] | 577 | void ClearMemory(); |
| 578 | |
rockot | 97a8683 | 2016-12-10 04:53:06 | [diff] [blame] | 579 | void Init( |
| 580 | const scoped_refptr<base::SingleThreadTaskRunner>& resource_task_queue); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 581 | |
vollick | 1050cc6 | 2015-12-03 07:04:54 | [diff] [blame] | 582 | void InitializeCompositorThread(); |
| 583 | |
jam | 75c4422 | 2016-03-23 05:34:24 | [diff] [blame] | 584 | void InitializeWebKit( |
Stuart Langley | 7b8dc77 | 2017-10-31 03:55:20 | [diff] [blame] | 585 | const scoped_refptr<base::SingleThreadTaskRunner>& resource_task_queue, |
Ken Rockot | 510c597 | 2017-12-05 16:37:04 | [diff] [blame] | 586 | service_manager::BinderRegistry* registry); |
jam | 75c4422 | 2016-03-23 05:34:24 | [diff] [blame] | 587 | |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 588 | void OnTransferBitmap(const SkBitmap& bitmap, int resource_id); |
[email protected] | b3df5a4 | 2010-05-11 14:31:09 | [diff] [blame] | 589 | void OnGetAccessibilityTree(); |
blundell | c00adf44 | 2016-09-16 10:43:41 | [diff] [blame] | 590 | |
rockot | 067ca55f | 2016-09-30 22:00:15 | [diff] [blame] | 591 | // mojom::Renderer: |
| 592 | void CreateView(mojom::CreateViewParamsPtr params) override; |
rockot | 53be7caf | 2016-10-04 20:17:08 | [diff] [blame] | 593 | void CreateFrame(mojom::CreateFrameParamsPtr params) override; |
Makoto Shimazu | 7af43ee | 2017-08-25 10:20:40 | [diff] [blame] | 594 | void SetUpEmbeddedWorkerChannelForServiceWorker( |
| 595 | mojom::EmbeddedWorkerInstanceClientAssociatedRequest client_request) |
| 596 | override; |
rockot | 53be7caf | 2016-10-04 20:17:08 | [diff] [blame] | 597 | 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; |
rockot | a2db0da | 2016-10-18 17:39:11 | [diff] [blame] | 602 | void OnNetworkConnectionChanged( |
| 603 | net::NetworkChangeNotifier::ConnectionType type, |
| 604 | double max_bandwidth_mbps) override; |
tbansal | b612c5d | 2017-05-25 18:53:06 | [diff] [blame] | 605 | void OnNetworkQualityChanged(net::EffectiveConnectionType type, |
| 606 | base::TimeDelta http_rtt, |
tbansal | 99d8aeb | 2017-05-22 19:12:58 | [diff] [blame] | 607 | base::TimeDelta transport_rtt, |
tbansal | 15973c3 | 2017-05-10 18:40:44 | [diff] [blame] | 608 | double bandwidth_kbps) override; |
rockot | a2db0da | 2016-10-18 17:39:11 | [diff] [blame] | 609 | 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 Verne | 5420564d | 2017-10-27 07:37:54 | [diff] [blame] | 616 | void SetProcessBackgrounded(bool backgrounded) override; |
| 617 | void ProcessPurgeAndSuspend() override; |
rockot | 067ca55f | 2016-09-30 22:00:15 | [diff] [blame] | 618 | |
[email protected] | 5071cb2 | 2013-07-10 02:19:06 | [diff] [blame] | 619 | void OnMemoryPressure( |
| 620 | base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level); |
rockot | a2db0da | 2016-10-18 17:39:11 | [diff] [blame] | 621 | |
rmcilroy | aa29605 | 2015-04-14 15:35:27 | [diff] [blame] | 622 | bool RendererIsHidden() const; |
| 623 | void OnRendererHidden(); |
| 624 | void OnRendererVisible(); |
[email protected] | b3df5a4 | 2010-05-11 14:31:09 | [diff] [blame] | 625 | |
tasak | 335a187 | 2017-06-14 09:50:23 | [diff] [blame] | 626 | void RecordMemoryUsageAfterBackgrounded(const char* suffix, |
| 627 | int foregrounded_count); |
tasak | bb0640b | 2017-05-15 09:02:26 | [diff] [blame] | 628 | void RecordPurgeAndSuspendMemoryGrowthMetrics( |
| 629 | const char* suffix, |
| 630 | int foregrounded_count_when_purged); |
tasak | b46626a | 2016-10-18 05:54:44 | [diff] [blame] | 631 | |
ssid | 0603ca9f | 2015-06-09 16:48:08 | [diff] [blame] | 632 | void ReleaseFreeMemory(); |
| 633 | |
hong.zheng | b28b533 | 2016-05-11 02:33:39 | [diff] [blame] | 634 | void OnSyncMemoryPressure( |
| 635 | base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level); |
| 636 | |
Fady Samuel | c645ffe | 2017-07-24 17:28:20 | [diff] [blame] | 637 | std::unique_ptr<viz::BeginFrameSource> CreateExternalBeginFrameSource( |
enne | 077ba486 | 2016-09-12 20:59:53 | [diff] [blame] | 638 | int routing_id); |
| 639 | |
Fady Samuel | c645ffe | 2017-07-24 17:28:20 | [diff] [blame] | 640 | std::unique_ptr<viz::SyntheticBeginFrameSource> |
samans | 09812d3 | 2017-03-27 19:51:50 | [diff] [blame] | 641 | CreateSyntheticBeginFrameSource(); |
| 642 | |
rockot | 067ca55f | 2016-09-30 22:00:15 | [diff] [blame] | 643 | void OnRendererInterfaceRequest(mojom::RendererAssociatedRequest request); |
| 644 | |
penghuang | 342762b | 2016-12-02 21:04:58 | [diff] [blame] | 645 | std::unique_ptr<discardable_memory::ClientDiscardableSharedMemoryManager> |
| 646 | discardable_shared_memory_manager_; |
| 647 | |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 648 | // These objects live solely on the render thread. |
dcheng | cedca561 | 2016-04-09 01:40:15 | [diff] [blame] | 649 | std::unique_ptr<AppCacheDispatcher> appcache_dispatcher_; |
| 650 | std::unique_ptr<DomStorageDispatcher> dom_storage_dispatcher_; |
| 651 | std::unique_ptr<IndexedDBDispatcher> main_thread_indexed_db_dispatcher_; |
skyostil | 529caa29 | 2016-08-10 17:44:51 | [diff] [blame] | 652 | std::unique_ptr<blink::scheduler::RendererScheduler> renderer_scheduler_; |
dcheng | cedca561 | 2016-04-09 01:40:15 | [diff] [blame] | 653 | std::unique_ptr<RendererBlinkPlatformImpl> blink_platform_impl_; |
John Abd-El-Malek | 6b56ef71 | 2017-10-21 22:52:46 | [diff] [blame] | 654 | std::unique_ptr<ResourceDispatcher> resource_dispatcher_; |
dcheng | cedca561 | 2016-04-09 01:40:15 | [diff] [blame] | 655 | std::unique_ptr<CacheStorageDispatcher> main_thread_cache_storage_dispatcher_; |
John Abd-El-Malek | dcf1d137 | 2017-10-22 06:39:41 | [diff] [blame] | 656 | std::unique_ptr<FileSystemDispatcher> file_system_dispatcher_; |
John Abd-El-Malek | f75a319 | 2017-10-22 14:23:20 | [diff] [blame] | 657 | std::unique_ptr<QuotaDispatcher> quota_dispatcher_; |
Yuzhu Shen | fe5f3a5 | 2018-01-11 21:24:13 | [diff] [blame^] | 658 | std::unique_ptr<URLLoaderThrottleProvider> url_loader_throttle_provider_; |
[email protected] | 9291ed1 | 2009-07-23 17:33:22 | [diff] [blame] | 659 | |
[email protected] | e2b2d4a | 2009-10-24 03:32:59 | [diff] [blame] | 660 | // Used on the renderer and IPC threads. |
dmurph | 1fb9848 | 2016-03-30 21:14:26 | [diff] [blame] | 661 | scoped_refptr<BlobMessageFilter> blob_message_filter_; |
[email protected] | f7eb0a39 | 2011-07-12 10:19:51 | [diff] [blame] | 662 | scoped_refptr<AudioInputMessageFilter> audio_input_message_filter_; |
[email protected] | 6e068ea | 2014-02-04 07:05:47 | [diff] [blame] | 663 | scoped_refptr<MidiMessageFilter> midi_message_filter_; |
John Abd-El-Malek | e1d4de3 | 2017-10-21 16:14:29 | [diff] [blame] | 664 | scoped_refptr<ServiceWorkerMessageFilter> service_worker_message_filter_; |
[email protected] | 017022b | 2009-07-27 23:06:34 | [diff] [blame] | 665 | |
dcheng | cedca561 | 2016-04-09 01:40:15 | [diff] [blame] | 666 | std::unique_ptr<BrowserPluginManager> browser_plugin_manager_; |
fsamuel | 6c1dfeb | 2014-12-18 19:21:33 | [diff] [blame] | 667 | |
Brett Wilson | 0748bf41 | 2016-11-22 17:55:46 | [diff] [blame] | 668 | #if BUILDFLAG(ENABLE_WEBRTC) |
dcheng | cedca561 | 2016-04-09 01:40:15 | [diff] [blame] | 669 | std::unique_ptr<PeerConnectionDependencyFactory> peer_connection_factory_; |
[email protected] | 6ee10bd | 2012-09-13 09:01:53 | [diff] [blame] | 670 | |
[email protected] | af08997 | 2013-01-10 04:04:40 | [diff] [blame] | 671 | // This is used to communicate to the browser process the status |
| 672 | // of all the peer connections created in the renderer. |
dcheng | cedca561 | 2016-04-09 01:40:15 | [diff] [blame] | 673 | std::unique_ptr<PeerConnectionTracker> peer_connection_tracker_; |
[email protected] | af08997 | 2013-01-10 04:04:40 | [diff] [blame] | 674 | |
[email protected] | 4761cf1 | 2012-09-12 10:37:55 | [diff] [blame] | 675 | // Dispatches all P2P sockets. |
[email protected] | e9ff79c | 2012-10-19 21:31:26 | [diff] [blame] | 676 | scoped_refptr<P2PSocketDispatcher> p2p_socket_dispatcher_; |
[email protected] | 80b161a | 2011-06-27 17:42:11 | [diff] [blame] | 677 | |
[email protected] | da9f30a | 2014-06-18 19:39:04 | [diff] [blame] | 678 | // 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_; |
liushouqun | 517b129 | 2016-09-14 05:58:59 | [diff] [blame] | 683 | #endif |
| 684 | |
maxmorin | 017ba8c6 | 2017-06-02 10:23:09 | [diff] [blame] | 685 | // 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 | |
liushouqun | 517b129 | 2016-09-14 05:58:59 | [diff] [blame] | 690 | // Used on the render thread. |
| 691 | std::unique_ptr<VideoCaptureImplManager> vc_manager_; |
[email protected] | da9f30a | 2014-06-18 19:39:04 | [diff] [blame] | 692 | |
danakj | 9242985 | 2017-06-29 00:19:03 | [diff] [blame] | 693 | std::unique_ptr<viz::ClientSharedBitmapManager> shared_bitmap_manager_; |
jcivelli | 0f21bd5 | 2016-12-07 21:21:33 | [diff] [blame] | 694 | |
John Abd-El-Malek | f9f86c1 | 2017-10-21 07:22:23 | [diff] [blame] | 695 | scoped_refptr<NotificationDispatcher> notification_dispatcher_; |
| 696 | |
Makoto Shimazu | 7af43ee | 2017-08-25 10:20:40 | [diff] [blame] | 697 | // The time Blink was initialized. Used for UMA. |
| 698 | base::TimeTicks blink_initialized_time_; |
| 699 | |
[email protected] | bee16aab | 2009-08-26 15:55:03 | [diff] [blame] | 700 | // 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. |
avi | 1023d01 | 2015-12-25 02:39:14 | [diff] [blame] | 707 | int64_t idle_notification_delay_in_ms_; |
[email protected] | bee16aab | 2009-08-26 15:55:03 | [diff] [blame] | 708 | |
[email protected] | 1784b2f | 2011-11-24 10:53:48 | [diff] [blame] | 709 | // The number of idle handler calls that skip sending idle notifications. |
| 710 | int idle_notifications_to_skip_; |
| 711 | |
Alexander Timin | 4b615223 | 2017-10-17 20:34:06 | [diff] [blame] | 712 | bool webkit_shared_timer_suspended_; |
[email protected] | c1f50aa | 2010-02-18 03:46:57 | [diff] [blame] | 713 | |
danakj | 83066a3 | 2016-06-21 02:34:49 | [diff] [blame] | 714 | // Used to control layout test specific behavior. |
| 715 | std::unique_ptr<LayoutTestDependencies> layout_test_deps_; |
[email protected] | 233567d | 2013-02-27 20:22:02 | [diff] [blame] | 716 | |
[email protected] | 71d6d85 | 2009-12-07 22:12:36 | [diff] [blame] | 717 | // Timer that periodically calls IdleHandler. |
danakj | 8c3eb80 | 2015-09-24 07:53:00 | [diff] [blame] | 718 | base::RepeatingTimer idle_timer_; |
[email protected] | 71d6d85 | 2009-12-07 22:12:36 | [diff] [blame] | 719 | |
danakj | ab9ef4d | 2017-10-31 23:38:33 | [diff] [blame] | 720 | // 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 | |
haraken | 53f081d | 2014-11-11 01:03:40 | [diff] [blame] | 725 | // The message loop of the renderer main thread. |
| 726 | // This message loop should be destructed before the RenderThreadImpl |
| 727 | // shuts down Blink. |
dcheng | cedca561 | 2016-04-09 01:40:15 | [diff] [blame] | 728 | std::unique_ptr<base::MessageLoop> main_message_loop_; |
haraken | 53f081d | 2014-11-11 01:03:40 | [diff] [blame] | 729 | |
[email protected] | ea5f70a | 2013-03-07 12:30:36 | [diff] [blame] | 730 | // May be null if overridden by ContentRendererClient. |
skyostil | 529caa29 | 2016-08-10 17:44:51 | [diff] [blame] | 731 | std::unique_ptr<blink::scheduler::WebThreadBase> compositor_thread_; |
[email protected] | ea5f70a | 2013-03-07 12:30:36 | [diff] [blame] | 732 | |
dcastagna | 7f45dada | 2015-10-19 20:17:35 | [diff] [blame] | 733 | // Utility class to provide GPU functionalities to media. |
dcastagna | 09bd6b3 | 2016-02-01 21:54:28 | [diff] [blame] | 734 | // 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-Sanchez | cfcca5d5 | 2017-07-07 02:32:59 | [diff] [blame] | 737 | std::vector<std::unique_ptr<GpuVideoAcceleratorFactoriesImpl>> gpu_factories_; |
dcastagna | 7f45dada | 2015-10-19 20:17:35 | [diff] [blame] | 738 | |
[email protected] | c1330c8 | 2013-06-06 02:23:25 | [diff] [blame] | 739 | // Thread for running multimedia operations (e.g., video decoding). |
dcheng | cedca561 | 2016-04-09 01:40:15 | [diff] [blame] | 740 | std::unique_ptr<base::Thread> media_thread_; |
[email protected] | c1330c8 | 2013-06-06 02:23:25 | [diff] [blame] | 741 | |
skyostil | 2d3b5bd | 2015-05-27 15:40:59 | [diff] [blame] | 742 | // Will point to appropriate task runner after initialization, |
[email protected] | ea5f70a | 2013-03-07 12:30:36 | [diff] [blame] | 743 | // regardless of whether |compositor_thread_| is overriden. |
skyostil | 2d3b5bd | 2015-05-27 15:40:59 | [diff] [blame] | 744 | scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner_; |
[email protected] | ea5f70a | 2013-03-07 12:30:36 | [diff] [blame] | 745 | |
dcastagna | b880e8f | 2015-06-30 20:16:06 | [diff] [blame] | 746 | // Pool of workers used for raster operations (e.g., tile rasterization). |
prashant.n | fad657e | 2016-06-01 07:52:17 | [diff] [blame] | 747 | scoped_refptr<CategorizedWorkerPool> categorized_worker_pool_; |
reveman | 34b7a152 | 2015-03-23 20:27:47 | [diff] [blame] | 748 | |
jdduke | 691dd57 | 2014-12-02 20:47:52 | [diff] [blame] | 749 | base::CancelableCallback<void(const IPC::Message&)> main_input_callback_; |
| 750 | scoped_refptr<IPC::MessageFilter> input_event_filter_; |
dcheng | cedca561 | 2016-04-09 01:40:15 | [diff] [blame] | 751 | std::unique_ptr<InputHandlerManager> input_handler_manager_; |
simonhong | a7e3ac4 | 2014-11-11 20:50:22 | [diff] [blame] | 752 | scoped_refptr<CompositorForwardingMessageFilter> compositor_message_filter_; |
[email protected] | 1842fe2 | 2012-08-13 23:24:35 | [diff] [blame] | 753 | |
boliu | bee541f4 | 2015-11-05 00:52:53 | [diff] [blame] | 754 | #if defined(OS_ANDROID) |
| 755 | scoped_refptr<SynchronousCompositorFilter> sync_compositor_message_filter_; |
siva.gunturi | 5d4feb05 | 2015-11-15 16:15:31 | [diff] [blame] | 756 | scoped_refptr<StreamTextureFactory> stream_texture_factory_; |
boliu | bee541f4 | 2015-11-05 00:52:53 | [diff] [blame] | 757 | #endif |
| 758 | |
sadrul | 85cc5d8 | 2016-12-20 03:37:41 | [diff] [blame] | 759 | scoped_refptr<ui::ContextProviderCommandBuffer> shared_main_thread_contexts_; |
[email protected] | c29b7ff | 2013-03-06 03:51:04 | [diff] [blame] | 760 | |
tyoshino | 832a58a | 2016-04-18 08:14:08 | [diff] [blame] | 761 | base::ObserverList<RenderThreadObserver> observers_; |
[email protected] | 1223d6ef | 2011-03-28 16:47:50 | [diff] [blame] | 762 | |
Victor Miura | ff648861 | 2017-12-21 04:16:15 | [diff] [blame] | 763 | scoped_refptr<viz::RasterContextProvider> shared_worker_context_provider_; |
[email protected] | 3b2afc3 | 2012-06-18 21:31:16 | [diff] [blame] | 764 | |
dcheng | cedca561 | 2016-04-09 01:40:15 | [diff] [blame] | 765 | std::unique_ptr<AudioRendererMixerManager> audio_renderer_mixer_manager_; |
[email protected] | 3958e97 | 2012-07-17 00:25:41 | [diff] [blame] | 766 | |
[email protected] | b2d9876 | 2012-09-03 17:04:06 | [diff] [blame] | 767 | HistogramCustomizer histogram_customizer_; |
| 768 | |
dcheng | cedca561 | 2016-04-09 01:40:15 | [diff] [blame] | 769 | std::unique_ptr<base::MemoryPressureListener> memory_pressure_listener_; |
[email protected] | 5071cb2 | 2013-07-10 02:19:06 | [diff] [blame] | 770 | |
bashi | a626404 | 2016-09-15 04:49:51 | [diff] [blame] | 771 | std::unique_ptr<ChildMemoryCoordinatorImpl> memory_coordinator_; |
[email protected] | fdeac26 | 2014-07-10 12:52:51 | [diff] [blame] | 772 | |
sadrul | 04cfa89 | 2016-12-09 17:53:49 | [diff] [blame] | 773 | std::unique_ptr<ui::Gpu> gpu_; |
sadrul | 9e0bb1d | 2016-08-04 20:18:39 | [diff] [blame] | 774 | |
skyostil | 457b0a1 | 2014-09-09 10:12:07 | [diff] [blame] | 775 | scoped_refptr<base::SingleThreadTaskRunner> |
| 776 | main_thread_compositor_task_runner_; |
skyostil | 457b0a1 | 2014-09-09 10:12:07 | [diff] [blame] | 777 | |
danakj | 6e3bf801 | 2014-12-16 18:27:53 | [diff] [blame] | 778 | // Compositor settings. |
[email protected] | a23530d | 2014-03-11 06:04:14 | [diff] [blame] | 779 | bool is_gpu_rasterization_forced_; |
senorblanco | b60ba95 | 2015-01-27 19:12:36 | [diff] [blame] | 780 | int gpu_rasterization_msaa_sample_count_; |
[email protected] | a23530d | 2014-03-11 06:04:14 | [diff] [blame] | 781 | bool is_lcd_text_enabled_; |
[email protected] | b242b14 | 2014-05-07 14:48:49 | [diff] [blame] | 782 | bool is_distance_field_text_enabled_; |
[email protected] | 2cccfef | 2014-05-01 06:05:16 | [diff] [blame] | 783 | bool is_zero_copy_enabled_; |
ccameron | c7fcd13 | 2015-11-03 20:14:31 | [diff] [blame] | 784 | bool is_gpu_memory_buffer_compositor_resources_enabled_; |
ericrk | 1d17f75 | 2015-10-20 03:03:07 | [diff] [blame] | 785 | bool is_partial_raster_enabled_; |
ccameron | a764475 | 2014-12-30 01:16:31 | [diff] [blame] | 786 | bool is_elastic_overscroll_enabled_; |
loyso | 65c93c60 | 2015-08-11 05:15:57 | [diff] [blame] | 787 | bool is_threaded_animation_enabled_; |
wjmaclean | 1d97062 | 2017-01-21 22:28:24 | [diff] [blame] | 788 | bool is_scroll_animator_enabled_; |
[email protected] | a23530d | 2014-03-11 06:04:14 | [diff] [blame] | 789 | |
Miguel Casas | 5e101805 | 2018-01-09 19:17:36 | [diff] [blame] | 790 | // Target rendering ColorSpace. |
| 791 | gfx::ColorSpace rendering_color_space_; |
| 792 | |
ben | 76f52b24 | 2016-06-18 05:42:48 | [diff] [blame] | 793 | class PendingFrameCreate : public base::RefCounted<PendingFrameCreate> { |
rockot | f8fdd9b | 2015-12-16 22:22:35 | [diff] [blame] | 794 | public: |
Balazs Engedy | ba034e7 | 2017-10-27 22:26:28 | [diff] [blame] | 795 | PendingFrameCreate(const service_manager::BindSourceInfo& source_info, |
| 796 | int routing_id, |
| 797 | mojom::FrameRequest frame_request); |
rockot | f8fdd9b | 2015-12-16 22:22:35 | [diff] [blame] | 798 | |
ben | f28ce88 | 2017-05-02 16:15:49 | [diff] [blame] | 799 | const service_manager::BindSourceInfo& browser_info() const { |
| 800 | return browser_info_; |
| 801 | } |
ben | 76f52b24 | 2016-06-18 05:42:48 | [diff] [blame] | 802 | mojom::FrameRequest TakeFrameRequest() { return std::move(frame_request_); } |
rockot | f8fdd9b | 2015-12-16 22:22:35 | [diff] [blame] | 803 | |
| 804 | private: |
ben | 76f52b24 | 2016-06-18 05:42:48 | [diff] [blame] | 805 | friend class base::RefCounted<PendingFrameCreate>; |
rockot | f8fdd9b | 2015-12-16 22:22:35 | [diff] [blame] | 806 | |
ben | 76f52b24 | 2016-06-18 05:42:48 | [diff] [blame] | 807 | ~PendingFrameCreate(); |
rockot | f8fdd9b | 2015-12-16 22:22:35 | [diff] [blame] | 808 | |
| 809 | // Mojo error handler. |
| 810 | void OnConnectionError(); |
| 811 | |
ben | f28ce88 | 2017-05-02 16:15:49 | [diff] [blame] | 812 | service_manager::BindSourceInfo browser_info_; |
rockot | f8fdd9b | 2015-12-16 22:22:35 | [diff] [blame] | 813 | int routing_id_; |
ben | 76f52b24 | 2016-06-18 05:42:48 | [diff] [blame] | 814 | mojom::FrameRequest frame_request_; |
rockot | f8fdd9b | 2015-12-16 22:22:35 | [diff] [blame] | 815 | }; |
| 816 | |
ben | 76f52b24 | 2016-06-18 05:42:48 | [diff] [blame] | 817 | using PendingFrameCreateMap = |
| 818 | std::map<int, scoped_refptr<PendingFrameCreate>>; |
| 819 | PendingFrameCreateMap pending_frame_creates_; |
rockot | f8fdd9b | 2015-12-16 22:22:35 | [diff] [blame] | 820 | |
leon.han | 06e5566 | 2016-03-26 17:19:42 | [diff] [blame] | 821 | mojom::StoragePartitionServicePtr storage_partition_service_; |
Joel Hockey | 3146d14 | 2017-11-15 22:27:40 | [diff] [blame] | 822 | mojom::RendererHostAssociatedPtr renderer_host_; |
jam | c912ca3 | 2016-02-24 20:17:31 | [diff] [blame] | 823 | |
rockot | 067ca55f | 2016-09-30 22:00:15 | [diff] [blame] | 824 | AssociatedInterfaceRegistryImpl associated_interfaces_; |
| 825 | |
| 826 | mojo::AssociatedBinding<mojom::Renderer> renderer_binding_; |
| 827 | |
rockot | 1587e33 | 2016-07-27 17:44:14 | [diff] [blame] | 828 | mojom::RenderFrameMessageFilterAssociatedPtr render_frame_message_filter_; |
rockot | e261d211 | 2016-09-21 22:22:23 | [diff] [blame] | 829 | mojom::RenderMessageFilterAssociatedPtr render_message_filter_; |
rockot | 1587e33 | 2016-07-27 17:44:14 | [diff] [blame] | 830 | |
tasak | 72f6404 | 2017-01-19 14:02:53 | [diff] [blame] | 831 | RendererMemoryMetrics purge_and_suspend_memory_metrics_; |
tasak | b95dbb50c | 2017-02-08 18:07:50 | [diff] [blame] | 832 | bool needs_to_record_first_active_paint_; |
Takashi SAKAMOTO | 870f626 | 2017-08-22 04:08:27 | [diff] [blame] | 833 | base::TimeTicks was_backgrounded_time_; |
tasak | bb0640b | 2017-05-15 09:02:26 | [diff] [blame] | 834 | int process_foregrounded_count_; |
hajimehoshi | 6909327 | 2016-05-13 08:30:58 | [diff] [blame] | 835 | |
staraz | 067f5824 | 2016-11-07 21:06:41 | [diff] [blame] | 836 | int32_t client_id_; |
| 837 | |
samans | 2040988b | 2017-04-11 23:58:35 | [diff] [blame] | 838 | mojom::FrameSinkProviderPtr frame_sink_provider_; |
| 839 | |
danakj | ab9ef4d | 2017-10-31 23:38:33 | [diff] [blame] | 840 | // 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 |
danakj | 4ee301c | 2017-11-29 16:19:43 | [diff] [blame] | 843 | // this member. |
danakj | ab9ef4d | 2017-10-31 23:38:33 | [diff] [blame] | 844 | mojo::Binding<viz::mojom::CompositingModeWatcher> |
| 845 | compositing_mode_watcher_binding_; |
| 846 | |
[email protected] | f1a29a0 | 2011-10-06 23:08:44 | [diff] [blame] | 847 | DISALLOW_COPY_AND_ASSIGN(RenderThreadImpl); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 848 | }; |
| 849 | |
jam | 8a021512a | 2015-02-03 18:16:08 | [diff] [blame] | 850 | #if defined(COMPILER_MSVC) |
| 851 | #pragma warning(pop) |
| 852 | #endif |
| 853 | |
[email protected] | e9ff79c | 2012-10-19 21:31:26 | [diff] [blame] | 854 | } // namespace content |
| 855 | |
[email protected] | f1a29a0 | 2011-10-06 23:08:44 | [diff] [blame] | 856 | #endif // CONTENT_RENDERER_RENDER_THREAD_IMPL_H_ |