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"
27 struct WebPreferences;
31 class GpuDataManagerImplPrivate;
33 class CONTENT_EXPORT GpuDataManagerImpl
34 : public NON_EXPORTED_BASE(GpuDataManager) {
36 // Indicates the guilt level of a domain which caused a GPU reset.
37 // If a domain is 100% known to be guilty of resetting the GPU, then
38 // it will generally not cause other domains' use of 3D APIs to be
39 // blocked, unless system stability would be compromised.
45 // Indicates the reason that access to a given client API (like
46 // WebGL or Pepper 3D) was blocked or not. This state is distinct
47 // from blacklisting of an entire feature.
48 enum DomainBlockStatus {
49 DOMAIN_BLOCK_STATUS_BLOCKED,
50 DOMAIN_BLOCK_STATUS_ALL_DOMAINS_BLOCKED,
51 DOMAIN_BLOCK_STATUS_NOT_BLOCKED
54 // Getter for the singleton. This will return NULL on failure.
55 static GpuDataManagerImpl* GetInstance();
57 // GpuDataManager implementation.
58 virtual void InitializeForTesting(
59 const std::string& gpu_blacklist_json,
60 const gpu::GPUInfo& gpu_info) OVERRIDE;
61 virtual bool IsFeatureBlacklisted(int feature) const OVERRIDE;
62 virtual gpu::GPUInfo GetGPUInfo() const OVERRIDE;
63 virtual void GetGpuProcessHandles(
64 const GetGpuProcessHandlesCallback& callback) const OVERRIDE;
65 virtual bool GpuAccessAllowed(std::string* reason) const OVERRIDE;
66 virtual void RequestCompleteGpuInfoIfNeeded() OVERRIDE;
67 virtual bool IsCompleteGpuInfoAvailable() const OVERRIDE;
68 virtual void RequestVideoMemoryUsageStatsUpdate() const OVERRIDE;
69 virtual bool ShouldUseSwiftShader() const OVERRIDE;
70 virtual void RegisterSwiftShaderPath(const base::FilePath& path) OVERRIDE;
71 virtual void AddObserver(GpuDataManagerObserver* observer) OVERRIDE;
72 virtual void RemoveObserver(GpuDataManagerObserver* observer) OVERRIDE;
73 virtual void UnblockDomainFrom3DAPIs(const GURL& url) OVERRIDE;
74 virtual void DisableGpuWatchdog() OVERRIDE;
75 virtual void SetGLStrings(const std::string& gl_vendor,
76 const std::string& gl_renderer,
77 const std::string& gl_version) OVERRIDE;
78 virtual void GetGLStrings(std::string* gl_vendor,
79 std::string* gl_renderer,
80 std::string* gl_version) OVERRIDE;
81 virtual void DisableHardwareAcceleration() OVERRIDE;
82 virtual bool CanUseGpuBrowserCompositor() const OVERRIDE;
84 // This collects preliminary GPU info, load GpuBlacklist, and compute the
85 // preliminary blacklisted features; it should only be called at browser
86 // startup time in UI thread before the IO restriction is turned on.
89 // Only update if the current GPUInfo is not finalized. If blacklist is
90 // loaded, run through blacklist and update blacklisted features.
91 void UpdateGpuInfo(const gpu::GPUInfo& gpu_info);
93 void UpdateVideoMemoryUsageStats(
94 const GPUVideoMemoryUsageStats& video_memory_usage_stats);
96 // Insert disable-feature switches corresponding to preliminary gpu feature
97 // flags into the renderer process command line.
98 void AppendRendererCommandLine(CommandLine* command_line) const;
100 // Insert switches into gpu process command line: kUseGL,
101 // kDisableGLMultisampling.
102 void AppendGpuCommandLine(CommandLine* command_line) const;
104 // Insert switches into plugin process command line:
105 // kDisableCoreAnimationPlugins.
106 void AppendPluginCommandLine(CommandLine* command_line) const;
108 // Update WebPreferences for renderer based on blacklisting decisions.
109 void UpdateRendererWebPrefs(WebPreferences* prefs) const;
111 std::string GetBlacklistVersion() const;
112 std::string GetDriverBugListVersion() const;
114 // Returns the reasons for the latest run of blacklisting decisions.
115 // For the structure of returned value, see documentation for
116 // GpuBlacklist::GetBlacklistedReasons().
117 void GetBlacklistReasons(base::ListValue* reasons) const;
119 // Returns the workarounds that are applied to the current system as
120 // a list of strings.
121 void GetDriverBugWorkarounds(base::ListValue* workarounds) const;
123 void AddLogMessage(int level,
124 const std::string& header,
125 const std::string& message);
127 void ProcessCrashed(base::TerminationStatus exit_code);
129 // Returns a new copy of the ListValue. Caller is responsible to release
130 // the returned value.
131 base::ListValue* GetLogMessages() const;
133 // Called when switching gpu.
134 void HandleGpuSwitch();
136 // Maintenance of domains requiring explicit user permission before
137 // using client-facing 3D APIs (WebGL, Pepper 3D), either because
138 // the domain has caused the GPU to reset, or because too many GPU
139 // resets have been observed globally recently, and system stability
140 // might be compromised.
142 // The given URL may be a partial URL (including at least the host)
143 // or a full URL to a page.
145 // Note that the unblocking API must be part of the content API
146 // because it is called from Chrome side code.
147 void BlockDomainFrom3DAPIs(const GURL& url, DomainGuilt guilt);
148 bool Are3DAPIsBlocked(const GURL& url,
149 int render_process_id,
151 ThreeDAPIType requester);
153 // Disables domain blocking for 3D APIs. For use only in tests.
154 void DisableDomainBlockingFor3DAPIsForTesting();
156 void Notify3DAPIBlocked(const GURL& url,
157 int render_process_id,
159 ThreeDAPIType requester);
161 // Get number of features being blacklisted.
162 size_t GetBlacklistedFeatureCount() const;
164 void SetDisplayCount(unsigned int display_count);
165 unsigned int GetDisplayCount() const;
167 // Called when GPU process initialization failed.
168 void OnGpuProcessInitFailure();
170 bool IsDriverBugWorkaroundActive(int feature) const;
173 friend class GpuDataManagerImplPrivate;
174 friend class GpuDataManagerImplPrivateTest;
175 friend struct DefaultSingletonTraits<GpuDataManagerImpl>;
177 // It's similar to AutoUnlock, but we want to make it a no-op
178 // if the owner GpuDataManagerImpl is null.
179 // This should only be used by GpuDataManagerImplPrivate where
180 // callbacks are called, during which re-entering
181 // GpuDataManagerImpl is possible.
182 class UnlockedSession {
184 explicit UnlockedSession(GpuDataManagerImpl* owner)
187 owner_->lock_.AssertAcquired();
188 owner_->lock_.Release();
193 owner_->lock_.Acquire();
197 GpuDataManagerImpl* owner_;
198 DISALLOW_COPY_AND_ASSIGN(UnlockedSession);
201 GpuDataManagerImpl();
202 virtual ~GpuDataManagerImpl();
204 mutable base::Lock lock_;
205 scoped_ptr<GpuDataManagerImplPrivate> private_;
207 DISALLOW_COPY_AND_ASSIGN(GpuDataManagerImpl);
210 } // namespace content
212 #endif // CONTENT_BROWSER_GPU_GPU_DATA_MANAGER_IMPL_H_