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