1// Copyright (c) 2013 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "content/browser/gpu/gpu_data_manager_impl.h"
6
7#include "content/browser/gpu/gpu_data_manager_impl_private.h"
8
9namespace content {
10
11// static
12GpuDataManager* GpuDataManager::GetInstance() {
13  return GpuDataManagerImpl::GetInstance();
14}
15
16// static
17GpuDataManagerImpl* GpuDataManagerImpl::GetInstance() {
18  return Singleton<GpuDataManagerImpl>::get();
19}
20
21void GpuDataManagerImpl::InitializeForTesting(
22    const std::string& gpu_blacklist_json, const gpu::GPUInfo& gpu_info) {
23  base::AutoLock auto_lock(lock_);
24  private_->InitializeForTesting(gpu_blacklist_json, gpu_info);
25}
26
27bool GpuDataManagerImpl::IsFeatureBlacklisted(int feature) const {
28  base::AutoLock auto_lock(lock_);
29  return private_->IsFeatureBlacklisted(feature);
30}
31
32bool GpuDataManagerImpl::IsDriverBugWorkaroundActive(int feature) const {
33  base::AutoLock auto_lock(lock_);
34  return private_->IsDriverBugWorkaroundActive(feature);
35}
36
37gpu::GPUInfo GpuDataManagerImpl::GetGPUInfo() const {
38  base::AutoLock auto_lock(lock_);
39  return private_->GetGPUInfo();
40}
41
42void GpuDataManagerImpl::GetGpuProcessHandles(
43    const GetGpuProcessHandlesCallback& callback) const {
44  base::AutoLock auto_lock(lock_);
45  private_->GetGpuProcessHandles(callback);
46}
47
48bool GpuDataManagerImpl::GpuAccessAllowed(std::string* reason) const {
49  base::AutoLock auto_lock(lock_);
50  return private_->GpuAccessAllowed(reason);
51}
52
53void GpuDataManagerImpl::RequestCompleteGpuInfoIfNeeded() {
54  base::AutoLock auto_lock(lock_);
55  private_->RequestCompleteGpuInfoIfNeeded();
56}
57
58bool GpuDataManagerImpl::IsEssentialGpuInfoAvailable() const {
59  base::AutoLock auto_lock(lock_);
60  return private_->IsEssentialGpuInfoAvailable();
61}
62
63bool GpuDataManagerImpl::IsCompleteGpuInfoAvailable() const {
64  base::AutoLock auto_lock(lock_);
65  return private_->IsCompleteGpuInfoAvailable();
66}
67
68void GpuDataManagerImpl::RequestVideoMemoryUsageStatsUpdate() const {
69  base::AutoLock auto_lock(lock_);
70  private_->RequestVideoMemoryUsageStatsUpdate();
71}
72
73bool GpuDataManagerImpl::ShouldUseSwiftShader() const {
74  base::AutoLock auto_lock(lock_);
75  return private_->ShouldUseSwiftShader();
76}
77
78void GpuDataManagerImpl::RegisterSwiftShaderPath(
79    const base::FilePath& path) {
80  base::AutoLock auto_lock(lock_);
81  private_->RegisterSwiftShaderPath(path);
82}
83
84bool GpuDataManagerImpl::ShouldUseWarp() const {
85  base::AutoLock auto_lock(lock_);
86  return private_->ShouldUseWarp();
87}
88
89void GpuDataManagerImpl::AddObserver(
90    GpuDataManagerObserver* observer) {
91  base::AutoLock auto_lock(lock_);
92  private_->AddObserver(observer);
93}
94
95void GpuDataManagerImpl::RemoveObserver(
96    GpuDataManagerObserver* observer) {
97  base::AutoLock auto_lock(lock_);
98  private_->RemoveObserver(observer);
99}
100
101void GpuDataManagerImpl::UnblockDomainFrom3DAPIs(const GURL& url) {
102  base::AutoLock auto_lock(lock_);
103  private_->UnblockDomainFrom3DAPIs(url);
104}
105
106void GpuDataManagerImpl::DisableGpuWatchdog() {
107  base::AutoLock auto_lock(lock_);
108  private_->DisableGpuWatchdog();
109}
110
111void GpuDataManagerImpl::SetGLStrings(const std::string& gl_vendor,
112                                      const std::string& gl_renderer,
113                                      const std::string& gl_version) {
114  base::AutoLock auto_lock(lock_);
115  private_->SetGLStrings(gl_vendor, gl_renderer, gl_version);
116}
117
118void GpuDataManagerImpl::GetGLStrings(std::string* gl_vendor,
119                                      std::string* gl_renderer,
120                                      std::string* gl_version) {
121  base::AutoLock auto_lock(lock_);
122  private_->GetGLStrings(gl_vendor, gl_renderer, gl_version);
123}
124
125void GpuDataManagerImpl::DisableHardwareAcceleration() {
126  base::AutoLock auto_lock(lock_);
127  private_->DisableHardwareAcceleration();
128}
129
130bool GpuDataManagerImpl::CanUseGpuBrowserCompositor() const {
131  base::AutoLock auto_lock(lock_);
132  return private_->CanUseGpuBrowserCompositor();
133}
134
135void GpuDataManagerImpl::Initialize() {
136  base::AutoLock auto_lock(lock_);
137  private_->Initialize();
138}
139
140void GpuDataManagerImpl::UpdateGpuInfo(const gpu::GPUInfo& gpu_info) {
141  base::AutoLock auto_lock(lock_);
142  private_->UpdateGpuInfo(gpu_info);
143}
144
145void GpuDataManagerImpl::UpdateVideoMemoryUsageStats(
146    const GPUVideoMemoryUsageStats& video_memory_usage_stats) {
147  base::AutoLock auto_lock(lock_);
148  private_->UpdateVideoMemoryUsageStats(video_memory_usage_stats);
149}
150
151void GpuDataManagerImpl::AppendRendererCommandLine(
152    base::CommandLine* command_line) const {
153  base::AutoLock auto_lock(lock_);
154  private_->AppendRendererCommandLine(command_line);
155}
156
157void GpuDataManagerImpl::AppendGpuCommandLine(
158    base::CommandLine* command_line) const {
159  base::AutoLock auto_lock(lock_);
160  private_->AppendGpuCommandLine(command_line);
161}
162
163void GpuDataManagerImpl::AppendPluginCommandLine(
164    base::CommandLine* command_line) const {
165  base::AutoLock auto_lock(lock_);
166  private_->AppendPluginCommandLine(command_line);
167}
168
169void GpuDataManagerImpl::UpdateRendererWebPrefs(
170    WebPreferences* prefs) const {
171  base::AutoLock auto_lock(lock_);
172  private_->UpdateRendererWebPrefs(prefs);
173}
174
175std::string GpuDataManagerImpl::GetBlacklistVersion() const {
176  base::AutoLock auto_lock(lock_);
177  return private_->GetBlacklistVersion();
178}
179
180std::string GpuDataManagerImpl::GetDriverBugListVersion() const {
181  base::AutoLock auto_lock(lock_);
182  return private_->GetDriverBugListVersion();
183}
184
185void GpuDataManagerImpl::GetBlacklistReasons(base::ListValue* reasons) const {
186  base::AutoLock auto_lock(lock_);
187  private_->GetBlacklistReasons(reasons);
188}
189
190void GpuDataManagerImpl::GetDriverBugWorkarounds(
191    base::ListValue* workarounds) const {
192  base::AutoLock auto_lock(lock_);
193  private_->GetDriverBugWorkarounds(workarounds);
194}
195
196void GpuDataManagerImpl::AddLogMessage(int level,
197                                       const std::string& header,
198                                       const std::string& message) {
199  base::AutoLock auto_lock(lock_);
200  private_->AddLogMessage(level, header, message);
201}
202
203void GpuDataManagerImpl::ProcessCrashed(
204    base::TerminationStatus exit_code) {
205  base::AutoLock auto_lock(lock_);
206  private_->ProcessCrashed(exit_code);
207}
208
209base::ListValue* GpuDataManagerImpl::GetLogMessages() const {
210  base::AutoLock auto_lock(lock_);
211  return private_->GetLogMessages();
212}
213
214void GpuDataManagerImpl::HandleGpuSwitch() {
215  base::AutoLock auto_lock(lock_);
216  private_->HandleGpuSwitch();
217}
218
219void GpuDataManagerImpl::BlockDomainFrom3DAPIs(
220    const GURL& url, DomainGuilt guilt) {
221  base::AutoLock auto_lock(lock_);
222  private_->BlockDomainFrom3DAPIs(url, guilt);
223}
224
225bool GpuDataManagerImpl::Are3DAPIsBlocked(const GURL& url,
226                                          int render_process_id,
227                                          int render_view_id,
228                                          ThreeDAPIType requester) {
229  base::AutoLock auto_lock(lock_);
230  return private_->Are3DAPIsBlocked(
231      url, render_process_id, render_view_id, requester);
232}
233
234void GpuDataManagerImpl::DisableDomainBlockingFor3DAPIsForTesting() {
235  base::AutoLock auto_lock(lock_);
236  private_->DisableDomainBlockingFor3DAPIsForTesting();
237}
238
239size_t GpuDataManagerImpl::GetBlacklistedFeatureCount() const {
240  base::AutoLock auto_lock(lock_);
241  return private_->GetBlacklistedFeatureCount();
242}
243
244void GpuDataManagerImpl::SetDisplayCount(unsigned int display_count) {
245  base::AutoLock auto_lock(lock_);
246  private_->SetDisplayCount(display_count);
247}
248
249unsigned int GpuDataManagerImpl::GetDisplayCount() const {
250  base::AutoLock auto_lock(lock_);
251  return private_->GetDisplayCount();
252}
253
254bool GpuDataManagerImpl::UpdateActiveGpu(uint32 vendor_id, uint32 device_id) {
255  base::AutoLock auto_lock(lock_);
256  return private_->UpdateActiveGpu(vendor_id, device_id);
257}
258
259void GpuDataManagerImpl::Notify3DAPIBlocked(const GURL& url,
260                                            int render_process_id,
261                                            int render_view_id,
262                                            ThreeDAPIType requester) {
263  base::AutoLock auto_lock(lock_);
264  private_->Notify3DAPIBlocked(
265      url, render_process_id, render_view_id, requester);
266}
267
268void GpuDataManagerImpl::OnGpuProcessInitFailure() {
269  base::AutoLock auto_lock(lock_);
270  private_->OnGpuProcessInitFailure();
271}
272
273GpuDataManagerImpl::GpuDataManagerImpl()
274    : private_(GpuDataManagerImplPrivate::Create(this)) {
275}
276
277GpuDataManagerImpl::~GpuDataManagerImpl() {
278}
279
280}  // namespace content
281