[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 | |
[email protected] | 6779aa1 | 2011-03-29 17:32:24 | [diff] [blame] | 8 | #include <set> |
[email protected] | b68d5ed | 2009-04-16 02:41:28 | [diff] [blame] | 9 | #include <string> |
[email protected] | 1bc8306 | 2009-02-06 00:16:37 | [diff] [blame] | 10 | #include <vector> |
| 11 | |
jdduke | 691dd57 | 2014-12-02 20:47:52 | [diff] [blame] | 12 | #include "base/cancelable_callback.h" |
[email protected] | 5071cb2 | 2013-07-10 02:19:06 | [diff] [blame] | 13 | #include "base/memory/memory_pressure_listener.h" |
rockot | 775ce0d | 2015-01-27 18:35:01 | [diff] [blame] | 14 | #include "base/memory/ref_counted.h" |
[email protected] | e6e30ac | 2014-01-13 21:24:39 | [diff] [blame] | 15 | #include "base/metrics/user_metrics_action.h" |
[email protected] | 1223d6ef | 2011-03-28 16:47:50 | [diff] [blame] | 16 | #include "base/observer_list.h" |
[email protected] | 21aa9968 | 2013-06-11 07:17:01 | [diff] [blame] | 17 | #include "base/strings/string16.h" |
[email protected] | 8810516 | 2013-12-05 01:02:12 | [diff] [blame] | 18 | #include "base/threading/thread_checker.h" |
[email protected] | abb52216 | 2013-06-28 01:54:16 | [diff] [blame] | 19 | #include "base/timer/timer.h" |
[email protected] | 037fce0 | 2009-01-22 01:42:15 | [diff] [blame] | 20 | #include "build/build_config.h" |
[email protected] | 10208ea | 2013-06-06 20:08:03 | [diff] [blame] | 21 | #include "content/child/child_thread.h" |
[email protected] | 8d128d6 | 2011-09-13 22:11:57 | [diff] [blame] | 22 | #include "content/common/content_export.h" |
alexmos | bc7eafa | 2014-12-06 01:38:09 | [diff] [blame] | 23 | #include "content/common/frame_replication_state.h" |
[email protected] | c26ad88 | 2012-02-07 06:41:20 | [diff] [blame] | 24 | #include "content/common/gpu/client/gpu_channel_host.h" |
[email protected] | a2c351d | 2014-07-14 23:42:39 | [diff] [blame] | 25 | #include "content/common/gpu/gpu_result_codes.h" |
[email protected] | 52647690 | 2011-10-06 20:34:06 | [diff] [blame] | 26 | #include "content/public/renderer/render_thread.h" |
danakj | 6e3bf801 | 2014-12-16 18:27:53 | [diff] [blame] | 27 | #include "content/renderer/gpu/compositor_dependencies.h" |
[email protected] | d7ff5fb | 2014-05-29 19:50:25 | [diff] [blame] | 28 | #include "net/base/network_change_notifier.h" |
| 29 | #include "third_party/WebKit/public/platform/WebConnectionType.h" |
[email protected] | 08397d5 | 2011-02-05 01:53:38 | [diff] [blame] | 30 | #include "ui/gfx/native_widget_types.h" |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 31 | |
[email protected] | 291857a | 2014-01-23 17:49:11 | [diff] [blame] | 32 | #if defined(OS_MACOSX) |
| 33 | #include "third_party/WebKit/public/web/mac/WebScrollbarTheme.h" |
| 34 | #endif |
| 35 | |
[email protected] | c29b7ff | 2013-03-06 03:51:04 | [diff] [blame] | 36 | class GrContext; |
[email protected] | 39008c0 | 2009-02-11 23:59:25 | [diff] [blame] | 37 | class SkBitmap; |
kenrb | a719983 | 2015-01-22 23:44:59 | [diff] [blame] | 38 | struct FrameMsg_NewFrame_WidgetParams; |
[email protected] | 9a292e2 | 2012-10-22 15:19:31 | [diff] [blame] | 39 | struct ViewMsg_New_Params; |
[email protected] | 0ec90d52 | 2014-03-12 16:28:19 | [diff] [blame] | 40 | struct WorkerProcessMsg_CreateWorker_Params; |
[email protected] | 46f36a49 | 2010-07-28 19:36:41 | [diff] [blame] | 41 | |
[email protected] | 180ef24 | 2013-11-07 06:50:46 | [diff] [blame] | 42 | namespace blink { |
[email protected] | ca998e5e | 2013-08-06 14:59:09 | [diff] [blame] | 43 | class WebGamepads; |
[email protected] | c29b7ff | 2013-03-06 03:51:04 | [diff] [blame] | 44 | class WebGraphicsContext3D; |
[email protected] | d8cd837 | 2012-03-09 10:49:51 | [diff] [blame] | 45 | class WebMediaStreamCenter; |
| 46 | class WebMediaStreamCenterClient; |
[email protected] | b7c7bcf | 2009-10-03 07:07:34 | [diff] [blame] | 47 | } |
| 48 | |
[email protected] | 64ffa044 | 2011-10-03 22:08:36 | [diff] [blame] | 49 | namespace base { |
| 50 | class MessageLoopProxy; |
skyostil | 457b0a1 | 2014-09-09 10:12:07 | [diff] [blame] | 51 | class SingleThreadTaskRunner; |
[email protected] | 64ffa044 | 2011-10-03 22:08:36 | [diff] [blame] | 52 | class Thread; |
| 53 | } |
| 54 | |
[email protected] | c29b7ff | 2013-03-06 03:51:04 | [diff] [blame] | 55 | namespace cc { |
| 56 | class ContextProvider; |
| 57 | } |
| 58 | |
[email protected] | 1842fe2 | 2012-08-13 23:24:35 | [diff] [blame] | 59 | namespace IPC { |
[email protected] | 7412204 | 2014-04-25 00:07:30 | [diff] [blame] | 60 | class MessageFilter; |
[email protected] | 1842fe2 | 2012-08-13 23:24:35 | [diff] [blame] | 61 | } |
| 62 | |
[email protected] | 563d665f | 2013-02-01 04:42:39 | [diff] [blame] | 63 | namespace media { |
| 64 | class AudioHardwareConfig; |
[email protected] | 2329bfc7 | 2014-02-28 02:03:21 | [diff] [blame] | 65 | class GpuVideoAcceleratorFactories; |
[email protected] | 563d665f | 2013-02-01 04:42:39 | [diff] [blame] | 66 | } |
| 67 | |
[email protected] | e9ff79c | 2012-10-19 21:31:26 | [diff] [blame] | 68 | namespace v8 { |
| 69 | class Extension; |
| 70 | } |
| 71 | |
[email protected] | c29b7ff | 2013-03-06 03:51:04 | [diff] [blame] | 72 | namespace webkit { |
| 73 | namespace gpu { |
[email protected] | 9cdd715 | 2014-01-14 14:20:43 | [diff] [blame] | 74 | class ContextProviderWebContext; |
[email protected] | c29b7ff | 2013-03-06 03:51:04 | [diff] [blame] | 75 | class GrContextForWebGraphicsContext3D; |
| 76 | } |
| 77 | } |
| 78 | |
[email protected] | 64ffa044 | 2011-10-03 22:08:36 | [diff] [blame] | 79 | namespace content { |
[email protected] | e9ff79c | 2012-10-19 21:31:26 | [diff] [blame] | 80 | |
[email protected] | eb39819 | 2012-10-22 20:16:19 | [diff] [blame] | 81 | class AppCacheDispatcher; |
[email protected] | da9f30a | 2014-06-18 19:39:04 | [diff] [blame] | 82 | class AecDumpMessageFilter; |
[email protected] | 9a292e2 | 2012-10-22 15:19:31 | [diff] [blame] | 83 | class AudioInputMessageFilter; |
| 84 | class AudioMessageFilter; |
[email protected] | 3958e97 | 2012-07-17 00:25:41 | [diff] [blame] | 85 | class AudioRendererMixerManager; |
fsamuel | 6c1dfeb | 2014-12-18 19:21:33 | [diff] [blame] | 86 | class BrowserPluginManager; |
simonhong | a7e3ac4 | 2014-11-11 20:50:22 | [diff] [blame] | 87 | class CompositorForwardingMessageFilter; |
[email protected] | a45c46e | 2013-03-07 01:04:46 | [diff] [blame] | 88 | class ContextProviderCommandBuffer; |
[email protected] | 3827e970 | 2012-10-23 06:19:28 | [diff] [blame] | 89 | class DBMessageFilter; |
[email protected] | e9ff79c | 2012-10-19 21:31:26 | [diff] [blame] | 90 | class DevToolsAgentFilter; |
| 91 | class DomStorageDispatcher; |
[email protected] | 7670d433 | 2013-11-29 04:35:00 | [diff] [blame] | 92 | class EmbeddedWorkerDispatcher; |
[email protected] | eb39819 | 2012-10-22 20:16:19 | [diff] [blame] | 93 | class GpuChannelHost; |
| 94 | class IndexedDBDispatcher; |
[email protected] | ea5f70a | 2013-03-07 12:30:36 | [diff] [blame] | 95 | class InputHandlerManager; |
[email protected] | d8cd837 | 2012-03-09 10:49:51 | [diff] [blame] | 96 | class MediaStreamCenter; |
[email protected] | fdeac26 | 2014-07-10 12:52:51 | [diff] [blame] | 97 | class MemoryObserver; |
[email protected] | 0107d8a | 2014-05-16 10:20:34 | [diff] [blame] | 98 | class PeerConnectionDependencyFactory; |
[email protected] | 6e068ea | 2014-02-04 07:05:47 | [diff] [blame] | 99 | class MidiMessageFilter; |
[email protected] | d7ff5fb | 2014-05-29 19:50:25 | [diff] [blame] | 100 | class NetInfoDispatcher; |
[email protected] | 4761cf1 | 2012-09-12 10:37:55 | [diff] [blame] | 101 | class P2PSocketDispatcher; |
[email protected] | af08997 | 2013-01-10 04:04:40 | [diff] [blame] | 102 | class PeerConnectionTracker; |
[email protected] | 64ffa044 | 2011-10-03 22:08:36 | [diff] [blame] | 103 | class RenderProcessObserver; |
tfarina | 556a723 | 2014-10-05 01:02:09 | [diff] [blame] | 104 | class RendererBlinkPlatformImpl; |
| 105 | class RendererDemuxerAndroid; |
rmcilroy | 321f924d | 2014-11-06 00:56:00 | [diff] [blame] | 106 | class RendererScheduler; |
alexclarke | 0bc36e8d3 | 2014-12-17 17:29:20 | [diff] [blame] | 107 | class ResourceSchedulingFilter; |
alph | 666f80f | 2014-12-08 15:52:11 | [diff] [blame] | 108 | class V8SamplingProfiler; |
[email protected] | 9a292e2 | 2012-10-22 15:19:31 | [diff] [blame] | 109 | class VideoCaptureImplManager; |
[email protected] | eb39819 | 2012-10-22 20:16:19 | [diff] [blame] | 110 | class WebGraphicsContext3DCommandBufferImpl; |
[email protected] | 921480f6 | 2013-07-20 03:42:57 | [diff] [blame] | 111 | class WebRTCIdentityService; |
[email protected] | cb25aa1 | 2012-08-07 19:13:43 | [diff] [blame] | 112 | |
[email protected] | f1a29a0 | 2011-10-06 23:08:44 | [diff] [blame] | 113 | // The RenderThreadImpl class represents a background thread where RenderView |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 114 | // instances live. The RenderThread supports an API that is used by its |
| 115 | // consumer to talk indirectly to the RenderViews and supporting objects. |
| 116 | // 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] | 117 | // process (i.e., their corresponding WebContentsImpl). |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 118 | // |
| 119 | // Most of the communication occurs in the form of IPC messages. They are |
| 120 | // routed to the RenderThread according to the routing IDs of the messages. |
| 121 | // The routing IDs correspond to RenderView instances. |
danakj | 6e3bf801 | 2014-12-16 18:27:53 | [diff] [blame] | 122 | class CONTENT_EXPORT RenderThreadImpl |
| 123 | : public RenderThread, |
| 124 | public ChildThread, |
| 125 | public GpuChannelHostFactory, |
| 126 | NON_EXPORTED_BASE(public CompositorDependencies) { |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 127 | public: |
[email protected] | f1a29a0 | 2011-10-06 23:08:44 | [diff] [blame] | 128 | static RenderThreadImpl* current(); |
[email protected] | 52647690 | 2011-10-06 20:34:06 | [diff] [blame] | 129 | |
[email protected] | f1a29a0 | 2011-10-06 23:08:44 | [diff] [blame] | 130 | RenderThreadImpl(); |
[email protected] | 8930d47 | 2009-02-21 08:05:28 | [diff] [blame] | 131 | // Constructor that's used when running in single process mode. |
[email protected] | f1a29a0 | 2011-10-06 23:08:44 | [diff] [blame] | 132 | explicit RenderThreadImpl(const std::string& channel_name); |
haraken | 53f081d | 2014-11-11 01:03:40 | [diff] [blame] | 133 | // Constructor that's used in RendererMain. |
| 134 | explicit RenderThreadImpl(scoped_ptr<base::MessageLoop> main_message_loop); |
dcheng | 6d18e40 | 2014-10-21 12:32:52 | [diff] [blame] | 135 | ~RenderThreadImpl() override; |
| 136 | void Shutdown() override; |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 137 | |
[email protected] | 58436a1 | 2012-03-21 17:10:26 | [diff] [blame] | 138 | // When initializing WebKit, ensure that any schemes needed for the content |
| 139 | // module are registered properly. Static to allow sharing with tests. |
| 140 | static void RegisterSchemes(); |
| 141 | |
[email protected] | df9accd | 2014-03-13 18:18:30 | [diff] [blame] | 142 | // Notify V8 that the date/time configuration of the system might have |
| 143 | // changed. |
| 144 | static void NotifyTimezoneChange(); |
| 145 | |
[email protected] | e9ff79c | 2012-10-19 21:31:26 | [diff] [blame] | 146 | // RenderThread implementation: |
dcheng | 6d18e40 | 2014-10-21 12:32:52 | [diff] [blame] | 147 | bool Send(IPC::Message* msg) override; |
alexclarke | 4a73c6a | 2015-01-08 14:34:00 | [diff] [blame] | 148 | scoped_refptr<base::SingleThreadTaskRunner> GetTaskRunner() override; |
dcheng | 6d18e40 | 2014-10-21 12:32:52 | [diff] [blame] | 149 | IPC::SyncChannel* GetChannel() override; |
| 150 | std::string GetLocale() override; |
| 151 | IPC::SyncMessageFilter* GetSyncMessageFilter() override; |
| 152 | scoped_refptr<base::MessageLoopProxy> GetIOMessageLoopProxy() override; |
| 153 | void AddRoute(int32 routing_id, IPC::Listener* listener) override; |
| 154 | void RemoveRoute(int32 routing_id) override; |
| 155 | int GenerateRoutingID() override; |
| 156 | void AddFilter(IPC::MessageFilter* filter) override; |
| 157 | void RemoveFilter(IPC::MessageFilter* filter) override; |
| 158 | void AddObserver(RenderProcessObserver* observer) override; |
| 159 | void RemoveObserver(RenderProcessObserver* observer) override; |
| 160 | void SetResourceDispatcherDelegate( |
mohan.reddy | ee0b42a | 2014-10-08 04:53:14 | [diff] [blame] | 161 | ResourceDispatcherDelegate* delegate) override; |
dcheng | 6d18e40 | 2014-10-21 12:32:52 | [diff] [blame] | 162 | void EnsureWebKitInitialized() override; |
| 163 | void RecordAction(const base::UserMetricsAction& action) override; |
| 164 | void RecordComputedAction(const std::string& action) override; |
| 165 | scoped_ptr<base::SharedMemory> HostAllocateSharedMemoryBuffer( |
mohan.reddy | ee0b42a | 2014-10-08 04:53:14 | [diff] [blame] | 166 | size_t buffer_size) override; |
jbauman | 2f5c194 | 2014-12-06 03:28:24 | [diff] [blame] | 167 | cc::SharedBitmapManager* GetSharedBitmapManager() override; |
dcheng | 6d18e40 | 2014-10-21 12:32:52 | [diff] [blame] | 168 | void RegisterExtension(v8::Extension* extension) override; |
| 169 | void ScheduleIdleHandler(int64 initial_delay_ms) override; |
| 170 | void IdleHandler() override; |
| 171 | int64 GetIdleNotificationDelayInMs() const override; |
| 172 | void SetIdleNotificationDelayInMs( |
mohan.reddy | ee0b42a | 2014-10-08 04:53:14 | [diff] [blame] | 173 | int64 idle_notification_delay_in_ms) override; |
dcheng | 6d18e40 | 2014-10-21 12:32:52 | [diff] [blame] | 174 | void UpdateHistograms(int sequence_number) override; |
| 175 | int PostTaskToAllWebWorkers(const base::Closure& closure) override; |
| 176 | bool ResolveProxy(const GURL& url, std::string* proxy_list) override; |
| 177 | base::WaitableEvent* GetShutdownEvent() override; |
[email protected] | 52647690 | 2011-10-06 20:34:06 | [diff] [blame] | 178 | #if defined(OS_WIN) |
mohan.reddy | ee0b42a | 2014-10-08 04:53:14 | [diff] [blame] | 179 | virtual void PreCacheFont(const LOGFONT& log_font) override; |
| 180 | virtual void ReleaseCachedFonts() override; |
[email protected] | 52647690 | 2011-10-06 20:34:06 | [diff] [blame] | 181 | #endif |
dcheng | 6d18e40 | 2014-10-21 12:32:52 | [diff] [blame] | 182 | ServiceRegistry* GetServiceRegistry() override; |
[email protected] | 1223d6ef | 2011-03-28 16:47:50 | [diff] [blame] | 183 | |
danakj | 6e3bf801 | 2014-12-16 18:27:53 | [diff] [blame] | 184 | // CompositorDependencies implementation. |
| 185 | bool IsImplSidePaintingEnabled() override; |
| 186 | bool IsGpuRasterizationForced() override; |
| 187 | bool IsGpuRasterizationEnabled() override; |
senorblanco | b60ba95 | 2015-01-27 19:12:36 | [diff] [blame^] | 188 | int GetGpuRasterizationMSAASampleCount() override; |
danakj | 6e3bf801 | 2014-12-16 18:27:53 | [diff] [blame] | 189 | bool IsLcdTextEnabled() override; |
| 190 | bool IsDistanceFieldTextEnabled() override; |
| 191 | bool IsZeroCopyEnabled() override; |
| 192 | bool IsOneCopyEnabled() override; |
ccameron | a764475 | 2014-12-30 01:16:31 | [diff] [blame] | 193 | bool IsElasticOverscrollEnabled() override; |
danakj | 6e3bf801 | 2014-12-16 18:27:53 | [diff] [blame] | 194 | uint32 GetImageTextureTarget() override; |
| 195 | scoped_refptr<base::SingleThreadTaskRunner> |
| 196 | GetCompositorMainThreadTaskRunner() override; |
| 197 | scoped_refptr<base::SingleThreadTaskRunner> |
| 198 | GetCompositorImplThreadTaskRunner() override; |
| 199 | gpu::GpuMemoryBufferManager* GetGpuMemoryBufferManager() override; |
| 200 | RendererScheduler* GetRendererScheduler() override; |
| 201 | cc::ContextProvider* GetSharedMainThreadContextProvider() override; |
| 202 | scoped_ptr<cc::BeginFrameSource> CreateExternalBeginFrameSource( |
| 203 | int routing_id) override; |
| 204 | |
[email protected] | b3e83de | 2012-02-07 03:33:28 | [diff] [blame] | 205 | // Synchronously establish a channel to the GPU plugin if not previously |
| 206 | // established or if it has been lost (for example if the GPU plugin crashed). |
| 207 | // If there is a pending asynchronous request, it will be completed by the |
| 208 | // time this routine returns. |
[email protected] | 96ab016c | 2013-10-23 00:50:29 | [diff] [blame] | 209 | GpuChannelHost* EstablishGpuChannelSync(CauseForGpuLaunch); |
[email protected] | b3e83de | 2012-02-07 03:33:28 | [diff] [blame] | 210 | |
| 211 | |
[email protected] | c1f50aa | 2010-02-18 03:46:57 | [diff] [blame] | 212 | // These methods modify how the next message is sent. Normally, when sending |
| 213 | // a synchronous message that runs a nested message loop, we need to suspend |
| 214 | // callbacks into WebKit. This involves disabling timers and deferring |
| 215 | // resource loads. However, there are exceptions when we need to customize |
| 216 | // the behavior. |
| 217 | void DoNotSuspendWebKitSharedTimer(); |
| 218 | void DoNotNotifyWebKitOfModalLoop(); |
| 219 | |
[email protected] | 70dee7e | 2013-05-29 18:28:30 | [diff] [blame] | 220 | // True if we are running layout tests. This currently disables forwarding |
| 221 | // various status messages to the console, skips network error pages, and |
| 222 | // short circuits size update and focus events. |
| 223 | bool layout_test_mode() const { |
| 224 | return layout_test_mode_; |
[email protected] | 233567d | 2013-02-27 20:22:02 | [diff] [blame] | 225 | } |
[email protected] | 70dee7e | 2013-05-29 18:28:30 | [diff] [blame] | 226 | void set_layout_test_mode(bool layout_test_mode) { |
| 227 | layout_test_mode_ = layout_test_mode; |
[email protected] | ac7f5a0 | 2013-03-16 16:14:41 | [diff] [blame] | 228 | } |
| 229 | |
tfarina | 556a723 | 2014-10-05 01:02:09 | [diff] [blame] | 230 | RendererBlinkPlatformImpl* blink_platform_impl() const { |
| 231 | DCHECK(blink_platform_impl_); |
| 232 | return blink_platform_impl_.get(); |
[email protected] | 078780b | 2014-06-20 16:57:06 | [diff] [blame] | 233 | } |
| 234 | |
simonhong | a7e3ac4 | 2014-11-11 20:50:22 | [diff] [blame] | 235 | CompositorForwardingMessageFilter* compositor_message_filter() const { |
| 236 | return compositor_message_filter_.get(); |
[email protected] | 1842fe2 | 2012-08-13 23:24:35 | [diff] [blame] | 237 | } |
| 238 | |
[email protected] | ea5f70a | 2013-03-07 12:30:36 | [diff] [blame] | 239 | InputHandlerManager* input_handler_manager() const { |
| 240 | return input_handler_manager_.get(); |
| 241 | } |
| 242 | |
danakj | 6e3bf801 | 2014-12-16 18:27:53 | [diff] [blame] | 243 | // Will be null if threaded compositing has not been enabled. |
[email protected] | ea5f70a | 2013-03-07 12:30:36 | [diff] [blame] | 244 | scoped_refptr<base::MessageLoopProxy> compositor_message_loop_proxy() const { |
| 245 | return compositor_message_loop_proxy_; |
[email protected] | a9fb30aa | 2011-10-06 06:58:46 | [diff] [blame] | 246 | } |
| 247 | |
[email protected] | f430b571 | 2009-08-21 21:46:31 | [diff] [blame] | 248 | AppCacheDispatcher* appcache_dispatcher() const { |
| 249 | return appcache_dispatcher_.get(); |
| 250 | } |
| 251 | |
[email protected] | 19b4951 | 2012-05-30 19:22:09 | [diff] [blame] | 252 | DomStorageDispatcher* dom_storage_dispatcher() const { |
| 253 | return dom_storage_dispatcher_.get(); |
| 254 | } |
| 255 | |
[email protected] | 7670d433 | 2013-11-29 04:35:00 | [diff] [blame] | 256 | EmbeddedWorkerDispatcher* embedded_worker_dispatcher() const { |
| 257 | return embedded_worker_dispatcher_.get(); |
| 258 | } |
| 259 | |
[email protected] | f7eb0a39 | 2011-07-12 10:19:51 | [diff] [blame] | 260 | AudioInputMessageFilter* audio_input_message_filter() { |
| 261 | return audio_input_message_filter_.get(); |
| 262 | } |
| 263 | |
| 264 | AudioMessageFilter* audio_message_filter() { |
| 265 | return audio_message_filter_.get(); |
| 266 | } |
| 267 | |
[email protected] | 6e068ea | 2014-02-04 07:05:47 | [diff] [blame] | 268 | MidiMessageFilter* midi_message_filter() { |
[email protected] | a987515 | 2013-06-22 04:03:03 | [diff] [blame] | 269 | return midi_message_filter_.get(); |
| 270 | } |
[email protected] | 6ee10bd | 2012-09-13 09:01:53 | [diff] [blame] | 271 | |
[email protected] | 6ca6a08 | 2013-09-22 20:10:05 | [diff] [blame] | 272 | #if defined(OS_ANDROID) |
| 273 | RendererDemuxerAndroid* renderer_demuxer() { |
| 274 | return renderer_demuxer_.get(); |
| 275 | } |
| 276 | #endif |
| 277 | |
[email protected] | d8cd837 | 2012-03-09 10:49:51 | [diff] [blame] | 278 | // Creates the embedder implementation of WebMediaStreamCenter. |
| 279 | // The resulting object is owned by WebKit and deleted by WebKit at tear-down. |
[email protected] | 180ef24 | 2013-11-07 06:50:46 | [diff] [blame] | 280 | blink::WebMediaStreamCenter* CreateMediaStreamCenter( |
| 281 | blink::WebMediaStreamCenterClient* client); |
[email protected] | d8cd837 | 2012-03-09 10:49:51 | [diff] [blame] | 282 | |
fsamuel | 6c1dfeb | 2014-12-18 19:21:33 | [diff] [blame] | 283 | BrowserPluginManager* browser_plugin_manager() const { |
| 284 | return browser_plugin_manager_.get(); |
| 285 | } |
| 286 | |
[email protected] | 22fe91d | 2014-08-12 17:07:12 | [diff] [blame] | 287 | #if defined(ENABLE_WEBRTC) |
[email protected] | 6ee10bd | 2012-09-13 09:01:53 | [diff] [blame] | 288 | // Returns a factory used for creating RTC PeerConnection objects. |
[email protected] | 0107d8a | 2014-05-16 10:20:34 | [diff] [blame] | 289 | PeerConnectionDependencyFactory* GetPeerConnectionDependencyFactory(); |
[email protected] | 6ee10bd | 2012-09-13 09:01:53 | [diff] [blame] | 290 | |
[email protected] | af08997 | 2013-01-10 04:04:40 | [diff] [blame] | 291 | PeerConnectionTracker* peer_connection_tracker() { |
| 292 | return peer_connection_tracker_.get(); |
| 293 | } |
| 294 | |
[email protected] | 4761cf1 | 2012-09-12 10:37:55 | [diff] [blame] | 295 | // Current P2PSocketDispatcher. Set to NULL if P2P API is disabled. |
[email protected] | e9ff79c | 2012-10-19 21:31:26 | [diff] [blame] | 296 | P2PSocketDispatcher* p2p_socket_dispatcher() { |
[email protected] | 4761cf1 | 2012-09-12 10:37:55 | [diff] [blame] | 297 | return p2p_socket_dispatcher_.get(); |
| 298 | } |
[email protected] | 22fe91d | 2014-08-12 17:07:12 | [diff] [blame] | 299 | #endif |
[email protected] | 4761cf1 | 2012-09-12 10:37:55 | [diff] [blame] | 300 | |
[email protected] | 80b161a | 2011-06-27 17:42:11 | [diff] [blame] | 301 | VideoCaptureImplManager* video_capture_impl_manager() const { |
| 302 | return vc_manager_.get(); |
| 303 | } |
| 304 | |
[email protected] | 6217d39 | 2010-03-25 22:08:35 | [diff] [blame] | 305 | // Get the GPU channel. Returns NULL if the channel is not established or |
| 306 | // has been lost. |
| 307 | GpuChannelHost* GetGpuChannel(); |
| 308 | |
[email protected] | c6a7b86 | 2010-08-20 22:19:38 | [diff] [blame] | 309 | // Returns a MessageLoopProxy instance corresponding to the message loop |
| 310 | // of the thread on which file operations should be run. Must be called |
| 311 | // on the renderer's main thread. |
| 312 | scoped_refptr<base::MessageLoopProxy> GetFileThreadMessageLoopProxy(); |
| 313 | |
acolwell | b403494 | 2014-08-28 15:42:43 | [diff] [blame] | 314 | // Returns a SingleThreadTaskRunner instance corresponding to the message loop |
[email protected] | c1330c8 | 2013-06-06 02:23:25 | [diff] [blame] | 315 | // of the thread on which media operations should be run. Must be called |
| 316 | // on the renderer's main thread. |
acolwell | b403494 | 2014-08-28 15:42:43 | [diff] [blame] | 317 | scoped_refptr<base::SingleThreadTaskRunner> GetMediaThreadTaskRunner(); |
[email protected] | c1330c8 | 2013-06-06 02:23:25 | [diff] [blame] | 318 | |
[email protected] | 1784b2f | 2011-11-24 10:53:48 | [diff] [blame] | 319 | // Causes the idle handler to skip sending idle notifications |
| 320 | // on the two next scheduled calls, so idle notifications are |
| 321 | // not sent for at least one notification delay. |
| 322 | void PostponeIdleNotification(); |
| 323 | |
[email protected] | 2329bfc7 | 2014-02-28 02:03:21 | [diff] [blame] | 324 | scoped_refptr<media::GpuVideoAcceleratorFactories> GetGpuFactories(); |
[email protected] | 3bb8bb3 | 2013-07-11 13:13:03 | [diff] [blame] | 325 | |
[email protected] | 9cdd715 | 2014-01-14 14:20:43 | [diff] [blame] | 326 | scoped_refptr<webkit::gpu::ContextProviderWebContext> |
| 327 | SharedMainThreadContextProvider(); |
[email protected] | c29b7ff | 2013-03-06 03:51:04 | [diff] [blame] | 328 | |
[email protected] | 3958e97 | 2012-07-17 00:25:41 | [diff] [blame] | 329 | // AudioRendererMixerManager instance which manages renderer side mixer |
| 330 | // instances shared based on configured audio parameters. Lazily created on |
| 331 | // first call. |
[email protected] | e9ff79c | 2012-10-19 21:31:26 | [diff] [blame] | 332 | AudioRendererMixerManager* GetAudioRendererMixerManager(); |
[email protected] | 3958e97 | 2012-07-17 00:25:41 | [diff] [blame] | 333 | |
[email protected] | 563d665f | 2013-02-01 04:42:39 | [diff] [blame] | 334 | // AudioHardwareConfig contains audio hardware configuration for |
| 335 | // renderer side clients. Creation requires a synchronous IPC call so it is |
| 336 | // lazily created on the first call. |
| 337 | media::AudioHardwareConfig* GetAudioHardwareConfig(); |
| 338 | |
[email protected] | feb3237 | 2012-11-21 01:14:56 | [diff] [blame] | 339 | #if defined(OS_WIN) |
[email protected] | fcf75d4 | 2013-12-03 20:11:26 | [diff] [blame] | 340 | void PreCacheFontCharacters(const LOGFONT& log_font, |
| 341 | const base::string16& str); |
[email protected] | feb3237 | 2012-11-21 01:14:56 | [diff] [blame] | 342 | #endif |
| 343 | |
[email protected] | 921480f6 | 2013-07-20 03:42:57 | [diff] [blame] | 344 | #if defined(ENABLE_WEBRTC) |
| 345 | WebRTCIdentityService* get_webrtc_identity_service() { |
| 346 | return webrtc_identity_service_.get(); |
| 347 | } |
| 348 | #endif |
| 349 | |
[email protected] | b2d9876 | 2012-09-03 17:04:06 | [diff] [blame] | 350 | // For producing custom V8 histograms. Custom histograms are produced if all |
| 351 | // RenderViews share the same host, and the host is in the pre-specified set |
| 352 | // of hosts we want to produce custom diagrams for. The name for a custom |
| 353 | // diagram is the name of the corresponding generic diagram plus a |
| 354 | // host-specific suffix. |
| 355 | class CONTENT_EXPORT HistogramCustomizer { |
| 356 | public: |
| 357 | HistogramCustomizer(); |
| 358 | ~HistogramCustomizer(); |
| 359 | |
| 360 | // Called when a top frame of a RenderView navigates. This function updates |
| 361 | // RenderThreadImpl's information about whether all RenderViews are |
| 362 | // displaying a page from the same host. |host| is the host where a |
| 363 | // RenderView navigated, and |view_count| is the number of RenderViews in |
| 364 | // this process. |
| 365 | void RenderViewNavigatedToHost(const std::string& host, size_t view_count); |
| 366 | |
| 367 | // Used for customizing some histograms if all RenderViews share the same |
| 368 | // host. Returns the current custom histogram name to use for |
| 369 | // |histogram_name|, or |histogram_name| if it shouldn't be customized. |
| 370 | std::string ConvertToCustomHistogramName(const char* histogram_name) const; |
| 371 | |
| 372 | private: |
| 373 | friend class RenderThreadImplUnittest; |
| 374 | |
| 375 | // Used for updating the information on which is the common host which all |
| 376 | // RenderView's share (if any). If there is no common host, this function is |
| 377 | // called with an empty string. |
| 378 | void SetCommonHost(const std::string& host); |
| 379 | |
| 380 | // The current common host of the RenderViews; empty string if there is no |
| 381 | // common host. |
| 382 | std::string common_host_; |
| 383 | // The corresponding suffix. |
| 384 | std::string common_host_histogram_suffix_; |
| 385 | // Set of histograms for which we want to produce a custom histogram if |
| 386 | // possible. |
| 387 | std::set<std::string> custom_histograms_; |
| 388 | |
| 389 | DISALLOW_COPY_AND_ASSIGN(HistogramCustomizer); |
| 390 | }; |
| 391 | |
| 392 | HistogramCustomizer* histogram_customizer() { |
| 393 | return &histogram_customizer_; |
| 394 | } |
| 395 | |
[email protected] | ca998e5e | 2013-08-06 14:59:09 | [diff] [blame] | 396 | // Retrieve current gamepad data. |
[email protected] | 180ef24 | 2013-11-07 06:50:46 | [diff] [blame] | 397 | void SampleGamepads(blink::WebGamepads* data); |
[email protected] | ca998e5e | 2013-08-06 14:59:09 | [diff] [blame] | 398 | |
[email protected] | b2db927 | 2014-01-10 17:42:00 | [diff] [blame] | 399 | // Called by a RenderWidget when it is created or destroyed. This |
| 400 | // allows the process to know when there are no visible widgets. |
| 401 | void WidgetCreated(); |
| 402 | void WidgetDestroyed(); |
| 403 | void WidgetHidden(); |
| 404 | void WidgetRestored(); |
| 405 | |
[email protected] | a620b13 | 2014-04-30 22:39:17 | [diff] [blame] | 406 | void AddEmbeddedWorkerRoute(int32 routing_id, IPC::Listener* listener); |
| 407 | void RemoveEmbeddedWorkerRoute(int32 routing_id); |
[email protected] | 48e52e4 | 2014-03-20 06:58:07 | [diff] [blame] | 408 | |
rockot | 775ce0d | 2015-01-27 18:35:01 | [diff] [blame] | 409 | void RegisterPendingRenderFrameConnect( |
| 410 | int routing_id, |
| 411 | mojo::InterfaceRequest<mojo::ServiceProvider> services, |
| 412 | mojo::ServiceProviderPtr exposed_services); |
[email protected] | c52a141 | 2014-06-25 06:09:25 | [diff] [blame] | 413 | |
alexclarke | 0bc36e8d3 | 2014-12-17 17:29:20 | [diff] [blame] | 414 | protected: |
| 415 | virtual void SetResourceDispatchTaskQueue( |
| 416 | const scoped_refptr<base::SingleThreadTaskRunner>& resource_task_queue); |
| 417 | |
[email protected] | 8930d47 | 2009-02-21 08:05:28 | [diff] [blame] | 418 | private: |
[email protected] | 57cf9788 | 2013-06-26 20:39:01 | [diff] [blame] | 419 | // ChildThread |
dcheng | 6d18e40 | 2014-10-21 12:32:52 | [diff] [blame] | 420 | bool OnControlMessageReceived(const IPC::Message& msg) override; |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 421 | |
[email protected] | 57cf9788 | 2013-06-26 20:39:01 | [diff] [blame] | 422 | // GpuChannelHostFactory implementation: |
dcheng | 6d18e40 | 2014-10-21 12:32:52 | [diff] [blame] | 423 | bool IsMainThread() override; |
| 424 | base::MessageLoop* GetMainLoop() override; |
| 425 | scoped_refptr<base::MessageLoopProxy> GetIOLoopProxy() override; |
| 426 | scoped_ptr<base::SharedMemory> AllocateSharedMemory(size_t size) override; |
| 427 | CreateCommandBufferResult CreateViewCommandBuffer( |
[email protected] | 57cf9788 | 2013-06-26 20:39:01 | [diff] [blame] | 428 | int32 surface_id, |
[email protected] | 0d78ec0e | 2014-04-08 23:35:23 | [diff] [blame] | 429 | const GPUCreateCommandBufferConfig& init_params, |
mohan.reddy | ee0b42a | 2014-10-08 04:53:14 | [diff] [blame] | 430 | int32 route_id) override; |
[email protected] | 57cf9788 | 2013-06-26 20:39:01 | [diff] [blame] | 431 | |
[email protected] | 42f1d782 | 2009-07-23 18:17:55 | [diff] [blame] | 432 | void Init(); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 433 | |
japhet | e6adf14 | 2014-10-31 00:01:49 | [diff] [blame] | 434 | void OnCreateNewFrame(int routing_id, |
| 435 | int parent_routing_id, |
alexmos | e48b1df93 | 2015-01-16 01:34:17 | [diff] [blame] | 436 | int proxy_routing_id, |
kenrb | a719983 | 2015-01-22 23:44:59 | [diff] [blame] | 437 | const FrameReplicationState& replicated_state, |
| 438 | FrameMsg_NewFrame_WidgetParams params); |
[email protected] | 82307f6b | 2014-08-07 03:30:12 | [diff] [blame] | 439 | void OnCreateNewFrameProxy(int routing_id, |
| 440 | int parent_routing_id, |
alexmos | bc7eafa | 2014-12-06 01:38:09 | [diff] [blame] | 441 | int render_view_routing_id, |
| 442 | const FrameReplicationState& replicated_state); |
[email protected] | 367c5c1d | 2013-03-11 18:59:02 | [diff] [blame] | 443 | void OnSetZoomLevelForCurrentURL(const std::string& scheme, |
| 444 | const std::string& host, |
| 445 | double zoom_level); |
[email protected] | 4e6419c | 2010-01-15 04:50:34 | [diff] [blame] | 446 | void OnCreateNewView(const ViewMsg_New_Params& params); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 447 | void OnTransferBitmap(const SkBitmap& bitmap, int resource_id); |
thestig | c4cac8f | 2014-09-04 21:17:50 | [diff] [blame] | 448 | #if defined(ENABLE_PLUGINS) |
[email protected] | b78e168b | 2009-09-21 22:05:45 | [diff] [blame] | 449 | void OnPurgePluginListCache(bool reload_pages); |
thestig | c4cac8f | 2014-09-04 21:17:50 | [diff] [blame] | 450 | #endif |
[email protected] | 8c2a34b | 2014-06-10 16:27:27 | [diff] [blame] | 451 | void OnNetworkTypeChanged(net::NetworkChangeNotifier::ConnectionType type); |
[email protected] | b3df5a4 | 2010-05-11 14:31:09 | [diff] [blame] | 452 | void OnGetAccessibilityTree(); |
[email protected] | b69934e | 2011-10-29 02:51:52 | [diff] [blame] | 453 | void OnTempCrashWithData(const GURL& data); |
[email protected] | df9accd | 2014-03-13 18:18:30 | [diff] [blame] | 454 | void OnUpdateTimezone(); |
[email protected] | 5071cb2 | 2013-07-10 02:19:06 | [diff] [blame] | 455 | void OnMemoryPressure( |
| 456 | base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level); |
[email protected] | b0988b2 | 2013-11-08 08:25:58 | [diff] [blame] | 457 | #if defined(OS_ANDROID) |
| 458 | void OnSetWebKitSharedTimersSuspended(bool suspend); |
| 459 | #endif |
| 460 | #if defined(OS_MACOSX) |
| 461 | void OnUpdateScrollbarTheme(float initial_button_delay, |
| 462 | float autoscroll_button_delay, |
| 463 | bool jump_on_track_click, |
[email protected] | 291857a | 2014-01-23 17:49:11 | [diff] [blame] | 464 | blink::ScrollerStyle preferred_scroller_style, |
[email protected] | b0988b2 | 2013-11-08 08:25:58 | [diff] [blame] | 465 | bool redraw); |
| 466 | #endif |
[email protected] | 0ec90d52 | 2014-03-12 16:28:19 | [diff] [blame] | 467 | void OnCreateNewSharedWorker( |
| 468 | const WorkerProcessMsg_CreateWorker_Params& params); |
[email protected] | b3df5a4 | 2010-05-11 14:31:09 | [diff] [blame] | 469 | |
[email protected] | c29b7ff | 2013-03-06 03:51:04 | [diff] [blame] | 470 | scoped_ptr<WebGraphicsContext3DCommandBufferImpl> CreateOffscreenContext3d(); |
| 471 | |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 472 | // These objects live solely on the render thread. |
[email protected] | f430b571 | 2009-08-21 21:46:31 | [diff] [blame] | 473 | scoped_ptr<AppCacheDispatcher> appcache_dispatcher_; |
[email protected] | 1910fe8 | 2012-05-10 00:04:10 | [diff] [blame] | 474 | scoped_ptr<DomStorageDispatcher> dom_storage_dispatcher_; |
[email protected] | 31bfae7 | 2011-12-16 02:04:38 | [diff] [blame] | 475 | scoped_ptr<IndexedDBDispatcher> main_thread_indexed_db_dispatcher_; |
rmcilroy | 321f924d | 2014-11-06 00:56:00 | [diff] [blame] | 476 | scoped_ptr<RendererScheduler> renderer_scheduler_; |
tfarina | 556a723 | 2014-10-05 01:02:09 | [diff] [blame] | 477 | scoped_ptr<RendererBlinkPlatformImpl> blink_platform_impl_; |
[email protected] | 7670d433 | 2013-11-29 04:35:00 | [diff] [blame] | 478 | scoped_ptr<EmbeddedWorkerDispatcher> embedded_worker_dispatcher_; |
[email protected] | 9291ed1 | 2009-07-23 17:33:22 | [diff] [blame] | 479 | |
[email protected] | d8cd837 | 2012-03-09 10:49:51 | [diff] [blame] | 480 | // Used on the render thread and deleted by WebKit at shutdown. |
[email protected] | 180ef24 | 2013-11-07 06:50:46 | [diff] [blame] | 481 | blink::WebMediaStreamCenter* media_stream_center_; |
[email protected] | d8cd837 | 2012-03-09 10:49:51 | [diff] [blame] | 482 | |
[email protected] | e2b2d4a | 2009-10-24 03:32:59 | [diff] [blame] | 483 | // Used on the renderer and IPC threads. |
[email protected] | 017022b | 2009-07-27 23:06:34 | [diff] [blame] | 484 | scoped_refptr<DBMessageFilter> db_message_filter_; |
[email protected] | f7eb0a39 | 2011-07-12 10:19:51 | [diff] [blame] | 485 | scoped_refptr<AudioInputMessageFilter> audio_input_message_filter_; |
| 486 | scoped_refptr<AudioMessageFilter> audio_message_filter_; |
[email protected] | 6e068ea | 2014-02-04 07:05:47 | [diff] [blame] | 487 | scoped_refptr<MidiMessageFilter> midi_message_filter_; |
[email protected] | 6ca6a08 | 2013-09-22 20:10:05 | [diff] [blame] | 488 | #if defined(OS_ANDROID) |
| 489 | scoped_refptr<RendererDemuxerAndroid> renderer_demuxer_; |
| 490 | #endif |
[email protected] | 8262245 | 2011-07-22 09:57:20 | [diff] [blame] | 491 | scoped_refptr<DevToolsAgentFilter> devtools_agent_message_filter_; |
alph | 666f80f | 2014-12-08 15:52:11 | [diff] [blame] | 492 | scoped_ptr<V8SamplingProfiler> v8_sampling_profiler_; |
[email protected] | 017022b | 2009-07-27 23:06:34 | [diff] [blame] | 493 | |
fsamuel | 6c1dfeb | 2014-12-18 19:21:33 | [diff] [blame] | 494 | scoped_ptr<BrowserPluginManager> browser_plugin_manager_; |
| 495 | |
[email protected] | 22fe91d | 2014-08-12 17:07:12 | [diff] [blame] | 496 | #if defined(ENABLE_WEBRTC) |
[email protected] | 83e0a48 | 2014-05-22 18:07:18 | [diff] [blame] | 497 | scoped_ptr<PeerConnectionDependencyFactory> peer_connection_factory_; |
[email protected] | 6ee10bd | 2012-09-13 09:01:53 | [diff] [blame] | 498 | |
[email protected] | af08997 | 2013-01-10 04:04:40 | [diff] [blame] | 499 | // This is used to communicate to the browser process the status |
| 500 | // of all the peer connections created in the renderer. |
| 501 | scoped_ptr<PeerConnectionTracker> peer_connection_tracker_; |
| 502 | |
[email protected] | 4761cf1 | 2012-09-12 10:37:55 | [diff] [blame] | 503 | // Dispatches all P2P sockets. |
[email protected] | e9ff79c | 2012-10-19 21:31:26 | [diff] [blame] | 504 | scoped_refptr<P2PSocketDispatcher> p2p_socket_dispatcher_; |
[email protected] | 22fe91d | 2014-08-12 17:07:12 | [diff] [blame] | 505 | #endif |
[email protected] | 4761cf1 | 2012-09-12 10:37:55 | [diff] [blame] | 506 | |
[email protected] | 4504807 | 2014-01-14 13:51:29 | [diff] [blame] | 507 | // Used on the render thread. |
| 508 | scoped_ptr<VideoCaptureImplManager> vc_manager_; |
[email protected] | 80b161a | 2011-06-27 17:42:11 | [diff] [blame] | 509 | |
[email protected] | da9f30a | 2014-06-18 19:39:04 | [diff] [blame] | 510 | // Used for communicating registering AEC dump consumers with the browser and |
| 511 | // receving AEC dump file handles when AEC dump is enabled. An AEC dump is |
| 512 | // diagnostic audio data for WebRTC stored locally when enabled by the user in |
| 513 | // chrome://webrtc-internals. |
| 514 | scoped_refptr<AecDumpMessageFilter> aec_dump_message_filter_; |
| 515 | |
[email protected] | bee16aab | 2009-08-26 15:55:03 | [diff] [blame] | 516 | // The count of RenderWidgets running through this thread. |
| 517 | int widget_count_; |
| 518 | |
| 519 | // The count of hidden RenderWidgets running through this thread. |
| 520 | int hidden_widget_count_; |
| 521 | |
| 522 | // The current value of the idle notification timer delay. |
[email protected] | 6593ae1 | 2011-11-14 12:09:44 | [diff] [blame] | 523 | int64 idle_notification_delay_in_ms_; |
[email protected] | bee16aab | 2009-08-26 15:55:03 | [diff] [blame] | 524 | |
[email protected] | 1784b2f | 2011-11-24 10:53:48 | [diff] [blame] | 525 | // The number of idle handler calls that skip sending idle notifications. |
| 526 | int idle_notifications_to_skip_; |
| 527 | |
[email protected] | 80fc08c5 | 2010-03-09 07:43:50 | [diff] [blame] | 528 | bool suspend_webkit_shared_timer_; |
| 529 | bool notify_webkit_of_modal_loop_; |
[email protected] | 26e8232 | 2014-01-20 14:18:22 | [diff] [blame] | 530 | bool webkit_shared_timer_suspended_; |
[email protected] | c1f50aa | 2010-02-18 03:46:57 | [diff] [blame] | 531 | |
[email protected] | 70dee7e | 2013-05-29 18:28:30 | [diff] [blame] | 532 | // The following flag is used to control layout test specific behavior. |
| 533 | bool layout_test_mode_; |
[email protected] | 233567d | 2013-02-27 20:22:02 | [diff] [blame] | 534 | |
[email protected] | 71d6d85 | 2009-12-07 22:12:36 | [diff] [blame] | 535 | // Timer that periodically calls IdleHandler. |
[email protected] | f1a29a0 | 2011-10-06 23:08:44 | [diff] [blame] | 536 | base::RepeatingTimer<RenderThreadImpl> idle_timer_; |
[email protected] | 71d6d85 | 2009-12-07 22:12:36 | [diff] [blame] | 537 | |
[email protected] | 6217d39 | 2010-03-25 22:08:35 | [diff] [blame] | 538 | // The channel from the renderer process to the GPU process. |
| 539 | scoped_refptr<GpuChannelHost> gpu_channel_; |
| 540 | |
[email protected] | 57cf9788 | 2013-06-26 20:39:01 | [diff] [blame] | 541 | // Cache of variables that are needed on the compositor thread by |
| 542 | // GpuChannelHostFactory methods. |
| 543 | scoped_refptr<base::MessageLoopProxy> io_message_loop_proxy_; |
[email protected] | 57cf9788 | 2013-06-26 20:39:01 | [diff] [blame] | 544 | |
haraken | 53f081d | 2014-11-11 01:03:40 | [diff] [blame] | 545 | // The message loop of the renderer main thread. |
| 546 | // This message loop should be destructed before the RenderThreadImpl |
| 547 | // shuts down Blink. |
| 548 | scoped_ptr<base::MessageLoop> main_message_loop_; |
| 549 | |
[email protected] | c6a7b86 | 2010-08-20 22:19:38 | [diff] [blame] | 550 | // A lazily initiated thread on which file operations are run. |
| 551 | scoped_ptr<base::Thread> file_thread_; |
| 552 | |
[email protected] | ea5f70a | 2013-03-07 12:30:36 | [diff] [blame] | 553 | // May be null if overridden by ContentRendererClient. |
| 554 | scoped_ptr<base::Thread> compositor_thread_; |
| 555 | |
[email protected] | c1330c8 | 2013-06-06 02:23:25 | [diff] [blame] | 556 | // Thread for running multimedia operations (e.g., video decoding). |
| 557 | scoped_ptr<base::Thread> media_thread_; |
| 558 | |
[email protected] | ea5f70a | 2013-03-07 12:30:36 | [diff] [blame] | 559 | // Will point to appropriate MessageLoopProxy after initialization, |
| 560 | // regardless of whether |compositor_thread_| is overriden. |
| 561 | scoped_refptr<base::MessageLoopProxy> compositor_message_loop_proxy_; |
| 562 | |
jdduke | 691dd57 | 2014-12-02 20:47:52 | [diff] [blame] | 563 | base::CancelableCallback<void(const IPC::Message&)> main_input_callback_; |
| 564 | scoped_refptr<IPC::MessageFilter> input_event_filter_; |
[email protected] | ea5f70a | 2013-03-07 12:30:36 | [diff] [blame] | 565 | scoped_ptr<InputHandlerManager> input_handler_manager_; |
simonhong | a7e3ac4 | 2014-11-11 20:50:22 | [diff] [blame] | 566 | scoped_refptr<CompositorForwardingMessageFilter> compositor_message_filter_; |
[email protected] | 1842fe2 | 2012-08-13 23:24:35 | [diff] [blame] | 567 | |
[email protected] | 807567a | 2014-08-11 19:48:41 | [diff] [blame] | 568 | scoped_refptr<webkit::gpu::ContextProviderWebContext> |
| 569 | shared_main_thread_contexts_; |
[email protected] | c29b7ff | 2013-03-06 03:51:04 | [diff] [blame] | 570 | |
[email protected] | e9ff79c | 2012-10-19 21:31:26 | [diff] [blame] | 571 | ObserverList<RenderProcessObserver> observers_; |
[email protected] | 1223d6ef | 2011-03-28 16:47:50 | [diff] [blame] | 572 | |
[email protected] | 93274ae | 2013-09-19 00:53:55 | [diff] [blame] | 573 | scoped_refptr<ContextProviderCommandBuffer> gpu_va_context_provider_; |
[email protected] | 3b2afc3 | 2012-06-18 21:31:16 | [diff] [blame] | 574 | |
[email protected] | e9ff79c | 2012-10-19 21:31:26 | [diff] [blame] | 575 | scoped_ptr<AudioRendererMixerManager> audio_renderer_mixer_manager_; |
[email protected] | 563d665f | 2013-02-01 04:42:39 | [diff] [blame] | 576 | scoped_ptr<media::AudioHardwareConfig> audio_hardware_config_; |
[email protected] | 3958e97 | 2012-07-17 00:25:41 | [diff] [blame] | 577 | |
[email protected] | b2d9876 | 2012-09-03 17:04:06 | [diff] [blame] | 578 | HistogramCustomizer histogram_customizer_; |
| 579 | |
[email protected] | 5071cb2 | 2013-07-10 02:19:06 | [diff] [blame] | 580 | scoped_ptr<base::MemoryPressureListener> memory_pressure_listener_; |
| 581 | |
[email protected] | 22fe91d | 2014-08-12 17:07:12 | [diff] [blame] | 582 | #if defined(ENABLE_WEBRTC) |
[email protected] | 921480f6 | 2013-07-20 03:42:57 | [diff] [blame] | 583 | scoped_ptr<WebRTCIdentityService> webrtc_identity_service_; |
[email protected] | 22fe91d | 2014-08-12 17:07:12 | [diff] [blame] | 584 | #endif |
[email protected] | 921480f6 | 2013-07-20 03:42:57 | [diff] [blame] | 585 | |
[email protected] | fdeac26 | 2014-07-10 12:52:51 | [diff] [blame] | 586 | scoped_ptr<MemoryObserver> memory_observer_; |
| 587 | |
skyostil | 457b0a1 | 2014-09-09 10:12:07 | [diff] [blame] | 588 | scoped_refptr<base::SingleThreadTaskRunner> |
| 589 | main_thread_compositor_task_runner_; |
skyostil | 457b0a1 | 2014-09-09 10:12:07 | [diff] [blame] | 590 | |
alexclarke | 0bc36e8d3 | 2014-12-17 17:29:20 | [diff] [blame] | 591 | scoped_refptr<ResourceSchedulingFilter> resource_scheduling_filter_; |
| 592 | |
danakj | 6e3bf801 | 2014-12-16 18:27:53 | [diff] [blame] | 593 | // Compositor settings. |
[email protected] | a23530d | 2014-03-11 06:04:14 | [diff] [blame] | 594 | bool is_gpu_rasterization_enabled_; |
| 595 | bool is_gpu_rasterization_forced_; |
senorblanco | b60ba95 | 2015-01-27 19:12:36 | [diff] [blame^] | 596 | int gpu_rasterization_msaa_sample_count_; |
[email protected] | a23530d | 2014-03-11 06:04:14 | [diff] [blame] | 597 | bool is_impl_side_painting_enabled_; |
| 598 | bool is_lcd_text_enabled_; |
[email protected] | b242b14 | 2014-05-07 14:48:49 | [diff] [blame] | 599 | bool is_distance_field_text_enabled_; |
[email protected] | 2cccfef | 2014-05-01 06:05:16 | [diff] [blame] | 600 | bool is_zero_copy_enabled_; |
| 601 | bool is_one_copy_enabled_; |
ccameron | a764475 | 2014-12-30 01:16:31 | [diff] [blame] | 602 | bool is_elastic_overscroll_enabled_; |
dongseong.hwang | 72183b0 | 2014-12-08 10:41:55 | [diff] [blame] | 603 | unsigned use_image_texture_target_; |
[email protected] | a23530d | 2014-03-11 06:04:14 | [diff] [blame] | 604 | |
rockot | 775ce0d | 2015-01-27 18:35:01 | [diff] [blame] | 605 | struct PendingRenderFrameConnect |
| 606 | : public base::RefCounted<PendingRenderFrameConnect> { |
| 607 | PendingRenderFrameConnect( |
| 608 | mojo::InterfaceRequest<mojo::ServiceProvider> services, |
| 609 | mojo::ServiceProviderPtr exposed_services); |
| 610 | |
| 611 | mojo::InterfaceRequest<mojo::ServiceProvider> services; |
| 612 | mojo::ServiceProviderPtr exposed_services; |
| 613 | |
| 614 | private: |
| 615 | friend class base::RefCounted<PendingRenderFrameConnect>; |
| 616 | |
| 617 | ~PendingRenderFrameConnect(); |
| 618 | }; |
| 619 | |
| 620 | typedef std::map<int, scoped_refptr<PendingRenderFrameConnect>> |
| 621 | PendingRenderFrameConnectMap; |
| 622 | PendingRenderFrameConnectMap pending_render_frame_connects_; |
[email protected] | c52a141 | 2014-06-25 06:09:25 | [diff] [blame] | 623 | |
[email protected] | f1a29a0 | 2011-10-06 23:08:44 | [diff] [blame] | 624 | DISALLOW_COPY_AND_ASSIGN(RenderThreadImpl); |
initial.commit | 09911bf | 2008-07-26 23:55:29 | [diff] [blame] | 625 | }; |
| 626 | |
[email protected] | e9ff79c | 2012-10-19 21:31:26 | [diff] [blame] | 627 | } // namespace content |
| 628 | |
[email protected] | f1a29a0 | 2011-10-06 23:08:44 | [diff] [blame] | 629 | #endif // CONTENT_RENDERER_RENDER_THREAD_IMPL_H_ |