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.
5 #ifndef CONTENT_BROWSER_GPU_GPU_DATA_MANAGER_IMPL_H_
6 #define CONTENT_BROWSER_GPU_GPU_DATA_MANAGER_IMPL_H_
10 #include "base/compiler_specific.h"
11 #include "base/files/file_path.h"
12 #include "base/gtest_prod_util.h"
13 #include "base/logging.h"
14 #include "base/memory/scoped_ptr.h"
15 #include "base/memory/singleton.h"
16 #include "base/process/kill.h"
17 #include "base/synchronization/lock.h"
18 #include "base/time/time.h"
19 #include "base/values.h"
20 #include "content/public/browser/gpu_data_manager.h"
21 #include "content/public/common/gpu_memory_stats.h"
22 #include "content/public/common/three_d_api_types.h"
23 #include "gpu/config/gpu_info.h"
33 class GpuDataManagerImplPrivate;
34 struct WebPreferences;
36 class CONTENT_EXPORT GpuDataManagerImpl
37 : public NON_EXPORTED_BASE(GpuDataManager) {
39 // Indicates the guilt level of a domain which caused a GPU reset.
40 // If a domain is 100% known to be guilty of resetting the GPU, then
41 // it will generally not cause other domains' use of 3D APIs to be
42 // blocked, unless system stability would be compromised.
48 // Indicates the reason that access to a given client API (like
49 // WebGL or Pepper 3D) was blocked or not. This state is distinct
50 // from blacklisting of an entire feature.
51 enum DomainBlockStatus {
52 DOMAIN_BLOCK_STATUS_BLOCKED,
53 DOMAIN_BLOCK_STATUS_ALL_DOMAINS_BLOCKED,
54 DOMAIN_BLOCK_STATUS_NOT_BLOCKED
57 // Getter for the singleton. This will return NULL on failure.
58 static GpuDataManagerImpl* GetInstance();
60 // GpuDataManager implementation.
61 virtual void InitializeForTesting(
62 const std::string& gpu_blacklist_json,
63 const gpu::GPUInfo& gpu_info) OVERRIDE;
64 virtual bool IsFeatureBlacklisted(int feature) const OVERRIDE;
65 virtual gpu::GPUInfo GetGPUInfo() const OVERRIDE;
66 virtual void GetGpuProcessHandles(
67 const GetGpuProcessHandlesCallback& callback) const OVERRIDE;
68 virtual bool GpuAccessAllowed(std::string* reason) const OVERRIDE;
69 virtual void RequestCompleteGpuInfoIfNeeded() OVERRIDE;
70 virtual bool IsEssentialGpuInfoAvailable() const OVERRIDE;
71 virtual bool IsCompleteGpuInfoAvailable() const OVERRIDE;
72 virtual void RequestVideoMemoryUsageStatsUpdate() const OVERRIDE;
73 virtual bool ShouldUseSwiftShader() const OVERRIDE;
74 virtual void RegisterSwiftShaderPath(const base::FilePath& path) OVERRIDE;
75 virtual bool ShouldUseWarp() const OVERRIDE;
76 virtual void AddObserver(GpuDataManagerObserver* observer) OVERRIDE;
77 virtual void RemoveObserver(GpuDataManagerObserver* observer) OVERRIDE;
78 virtual void UnblockDomainFrom3DAPIs(const GURL& url) OVERRIDE;
79 virtual void DisableGpuWatchdog() OVERRIDE;
80 virtual void SetGLStrings(const std::string& gl_vendor,
81 const std::string& gl_renderer,
82 const std::string& gl_version) OVERRIDE;
83 virtual void GetGLStrings(std::string* gl_vendor,
84 std::string* gl_renderer,
85 std::string* gl_version) OVERRIDE;
86 virtual void DisableHardwareAcceleration() OVERRIDE;
87 virtual bool CanUseGpuBrowserCompositor() const OVERRIDE;
89 // This collects preliminary GPU info, load GpuBlacklist, and compute the
90 // preliminary blacklisted features; it should only be called at browser
91 // startup time in UI thread before the IO restriction is turned on.
94 // Only update if the current GPUInfo is not finalized. If blacklist is
95 // loaded, run through blacklist and update blacklisted features.
96 void UpdateGpuInfo(const gpu::GPUInfo& gpu_info);
98 void UpdateVideoMemoryUsageStats(
99 const GPUVideoMemoryUsageStats& video_memory_usage_stats);
101 // Insert disable-feature switches corresponding to preliminary gpu feature
102 // flags into the renderer process command line.
103 void AppendRendererCommandLine(base::CommandLine* command_line) const;
105 // Insert switches into gpu process command line: kUseGL, etc.
106 void AppendGpuCommandLine(base::CommandLine* command_line) const;
108 // Insert switches into plugin process command line:
109 // kDisableCoreAnimationPlugins.
110 void AppendPluginCommandLine(base::CommandLine* command_line) const;
112 // Update WebPreferences for renderer based on blacklisting decisions.
113 void UpdateRendererWebPrefs(WebPreferences* prefs) const;
115 std::string GetBlacklistVersion() const;
116 std::string GetDriverBugListVersion() const;
118 // Returns the reasons for the latest run of blacklisting decisions.
119 // For the structure of returned value, see documentation for
120 // GpuBlacklist::GetBlacklistedReasons().
121 void GetBlacklistReasons(base::ListValue* reasons) const;
123 // Returns the workarounds that are applied to the current system as
124 // a list of strings.
125 void GetDriverBugWorkarounds(base::ListValue* workarounds) const;
127 void AddLogMessage(int level,
128 const std::string& header,
129 const std::string& message);
131 void ProcessCrashed(base::TerminationStatus exit_code);
133 // Returns a new copy of the ListValue. Caller is responsible to release
134 // the returned value.
135 base::ListValue* GetLogMessages() const;
137 // Called when switching gpu.
138 void HandleGpuSwitch();
140 // Maintenance of domains requiring explicit user permission before
141 // using client-facing 3D APIs (WebGL, Pepper 3D), either because
142 // the domain has caused the GPU to reset, or because too many GPU
143 // resets have been observed globally recently, and system stability
144 // might be compromised.
146 // The given URL may be a partial URL (including at least the host)
147 // or a full URL to a page.
149 // Note that the unblocking API must be part of the content API
150 // because it is called from Chrome side code.
151 void BlockDomainFrom3DAPIs(const GURL& url, DomainGuilt guilt);
152 bool Are3DAPIsBlocked(const GURL& url,
153 int render_process_id,
155 ThreeDAPIType requester);
157 // Disables domain blocking for 3D APIs. For use only in tests.
158 void DisableDomainBlockingFor3DAPIsForTesting();
160 void Notify3DAPIBlocked(const GURL& url,
161 int render_process_id,
163 ThreeDAPIType requester);
165 // Get number of features being blacklisted.
166 size_t GetBlacklistedFeatureCount() const;
168 void SetDisplayCount(unsigned int display_count);
169 unsigned int GetDisplayCount() const;
171 // Set the active gpu.
172 // Return true if it's a different GPU from the previous active one.
173 bool UpdateActiveGpu(uint32 vendor_id, uint32 device_id);
175 // Called when GPU process initialization failed.
176 void OnGpuProcessInitFailure();
178 bool IsDriverBugWorkaroundActive(int feature) const;
181 friend class GpuDataManagerImplPrivate;
182 friend class GpuDataManagerImplPrivateTest;
183 friend struct DefaultSingletonTraits<GpuDataManagerImpl>;
185 // It's similar to AutoUnlock, but we want to make it a no-op
186 // if the owner GpuDataManagerImpl is null.
187 // This should only be used by GpuDataManagerImplPrivate where
188 // callbacks are called, during which re-entering
189 // GpuDataManagerImpl is possible.
190 class UnlockedSession {
192 explicit UnlockedSession(GpuDataManagerImpl* owner)
195 owner_->lock_.AssertAcquired();
196 owner_->lock_.Release();
201 owner_->lock_.Acquire();
205 GpuDataManagerImpl* owner_;
206 DISALLOW_COPY_AND_ASSIGN(UnlockedSession);
209 GpuDataManagerImpl();
210 virtual ~GpuDataManagerImpl();
212 mutable base::Lock lock_;
213 scoped_ptr<GpuDataManagerImplPrivate> private_;
215 DISALLOW_COPY_AND_ASSIGN(GpuDataManagerImpl);
218 } // namespace content
220 #endif // CONTENT_BROWSER_GPU_GPU_DATA_MANAGER_IMPL_H_