1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
|
// Copyright (c) 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CONTENT_BROWSER_GPU_GPU_DATA_MANAGER_IMPL_H_
#define CONTENT_BROWSER_GPU_GPU_DATA_MANAGER_IMPL_H_
#include <string>
#include "base/compiler_specific.h"
#include "base/files/file_path.h"
#include "base/gtest_prod_util.h"
#include "base/logging.h"
#include "base/memory/scoped_ptr.h"
#include "base/memory/singleton.h"
#include "base/process/kill.h"
#include "base/synchronization/lock.h"
#include "base/time/time.h"
#include "base/values.h"
#include "content/public/browser/gpu_data_manager.h"
#include "content/public/common/gpu_memory_stats.h"
#include "content/public/common/three_d_api_types.h"
#include "gpu/config/gpu_info.h"
#include "gpu/config/gpu_switching_option.h"
class CommandLine;
class GURL;
struct WebPreferences;
namespace content {
class GpuDataManagerImplPrivate;
class CONTENT_EXPORT GpuDataManagerImpl
: public NON_EXPORTED_BASE(GpuDataManager) {
public:
// Indicates the guilt level of a domain which caused a GPU reset.
// If a domain is 100% known to be guilty of resetting the GPU, then
// it will generally not cause other domains' use of 3D APIs to be
// blocked, unless system stability would be compromised.
enum DomainGuilt {
DOMAIN_GUILT_KNOWN,
DOMAIN_GUILT_UNKNOWN
};
// Indicates the reason that access to a given client API (like
// WebGL or Pepper 3D) was blocked or not. This state is distinct
// from blacklisting of an entire feature.
enum DomainBlockStatus {
DOMAIN_BLOCK_STATUS_BLOCKED,
DOMAIN_BLOCK_STATUS_ALL_DOMAINS_BLOCKED,
DOMAIN_BLOCK_STATUS_NOT_BLOCKED
};
// Getter for the singleton. This will return NULL on failure.
static GpuDataManagerImpl* GetInstance();
// GpuDataManager implementation.
virtual void InitializeForTesting(
const std::string& gpu_blacklist_json,
const gpu::GPUInfo& gpu_info) OVERRIDE;
virtual bool IsFeatureBlacklisted(int feature) const OVERRIDE;
virtual gpu::GPUInfo GetGPUInfo() const OVERRIDE;
virtual void GetGpuProcessHandles(
const GetGpuProcessHandlesCallback& callback) const OVERRIDE;
virtual bool GpuAccessAllowed(std::string* reason) const OVERRIDE;
virtual void RequestCompleteGpuInfoIfNeeded() OVERRIDE;
virtual bool IsCompleteGpuInfoAvailable() const OVERRIDE;
virtual void RequestVideoMemoryUsageStatsUpdate() const OVERRIDE;
virtual bool ShouldUseSwiftShader() const OVERRIDE;
virtual void RegisterSwiftShaderPath(const base::FilePath& path) OVERRIDE;
virtual void AddObserver(GpuDataManagerObserver* observer) OVERRIDE;
virtual void RemoveObserver(GpuDataManagerObserver* observer) OVERRIDE;
virtual void UnblockDomainFrom3DAPIs(const GURL& url) OVERRIDE;
virtual void DisableGpuWatchdog() OVERRIDE;
virtual void SetGLStrings(const std::string& gl_vendor,
const std::string& gl_renderer,
const std::string& gl_version) OVERRIDE;
virtual void GetGLStrings(std::string* gl_vendor,
std::string* gl_renderer,
std::string* gl_version) OVERRIDE;
virtual void DisableHardwareAcceleration() OVERRIDE;
virtual bool CanUseGpuBrowserCompositor() const OVERRIDE;
// This collects preliminary GPU info, load GpuBlacklist, and compute the
// preliminary blacklisted features; it should only be called at browser
// startup time in UI thread before the IO restriction is turned on.
void Initialize();
// Only update if the current GPUInfo is not finalized. If blacklist is
// loaded, run through blacklist and update blacklisted features.
void UpdateGpuInfo(const gpu::GPUInfo& gpu_info);
void UpdateVideoMemoryUsageStats(
const GPUVideoMemoryUsageStats& video_memory_usage_stats);
// Insert disable-feature switches corresponding to preliminary gpu feature
// flags into the renderer process command line.
void AppendRendererCommandLine(CommandLine* command_line) const;
// Insert switches into gpu process command line: kUseGL,
// kDisableGLMultisampling.
void AppendGpuCommandLine(CommandLine* command_line) const;
// Insert switches into plugin process command line:
// kDisableCoreAnimationPlugins.
void AppendPluginCommandLine(CommandLine* command_line) const;
// Update WebPreferences for renderer based on blacklisting decisions.
void UpdateRendererWebPrefs(WebPreferences* prefs) const;
gpu::GpuSwitchingOption GetGpuSwitchingOption() const;
std::string GetBlacklistVersion() const;
std::string GetDriverBugListVersion() const;
// Returns the reasons for the latest run of blacklisting decisions.
// For the structure of returned value, see documentation for
// GpuBlacklist::GetBlacklistedReasons().
void GetBlacklistReasons(base::ListValue* reasons) const;
// Returns the workarounds that are applied to the current system as
// a list of strings.
void GetDriverBugWorkarounds(base::ListValue* workarounds) const;
void AddLogMessage(int level,
const std::string& header,
const std::string& message);
void ProcessCrashed(base::TerminationStatus exit_code);
// Returns a new copy of the ListValue. Caller is responsible to release
// the returned value.
base::ListValue* GetLogMessages() const;
// Called when switching gpu.
void HandleGpuSwitch();
#if defined(OS_WIN)
// Is the GPU process using the accelerated surface to present, instead of
// presenting by itself.
bool IsUsingAcceleratedSurface() const;
#endif
// Maintenance of domains requiring explicit user permission before
// using client-facing 3D APIs (WebGL, Pepper 3D), either because
// the domain has caused the GPU to reset, or because too many GPU
// resets have been observed globally recently, and system stability
// might be compromised.
//
// The given URL may be a partial URL (including at least the host)
// or a full URL to a page.
//
// Note that the unblocking API must be part of the content API
// because it is called from Chrome side code.
void BlockDomainFrom3DAPIs(const GURL& url, DomainGuilt guilt);
bool Are3DAPIsBlocked(const GURL& url,
int render_process_id,
int render_view_id,
ThreeDAPIType requester);
// Disables domain blocking for 3D APIs. For use only in tests.
void DisableDomainBlockingFor3DAPIsForTesting();
void Notify3DAPIBlocked(const GURL& url,
int render_process_id,
int render_view_id,
ThreeDAPIType requester);
// Get number of features being blacklisted.
size_t GetBlacklistedFeatureCount() const;
void SetDisplayCount(unsigned int display_count);
unsigned int GetDisplayCount() const;
// Called when GPU process initialization failed.
void OnGpuProcessInitFailure();
bool IsDriverBugWorkaroundActive(int feature) const;
private:
friend class GpuDataManagerImplPrivate;
friend class GpuDataManagerImplPrivateTest;
friend struct DefaultSingletonTraits<GpuDataManagerImpl>;
// It's similar to AutoUnlock, but we want to make it a no-op
// if the owner GpuDataManagerImpl is null.
// This should only be used by GpuDataManagerImplPrivate where
// callbacks are called, during which re-entering
// GpuDataManagerImpl is possible.
class UnlockedSession {
public:
explicit UnlockedSession(GpuDataManagerImpl* owner)
: owner_(owner) {
DCHECK(owner_);
owner_->lock_.AssertAcquired();
owner_->lock_.Release();
}
~UnlockedSession() {
DCHECK(owner_);
owner_->lock_.Acquire();
}
private:
GpuDataManagerImpl* owner_;
DISALLOW_COPY_AND_ASSIGN(UnlockedSession);
};
GpuDataManagerImpl();
virtual ~GpuDataManagerImpl();
mutable base::Lock lock_;
scoped_ptr<GpuDataManagerImplPrivate> private_;
DISALLOW_COPY_AND_ASSIGN(GpuDataManagerImpl);
};
} // namespace content
#endif // CONTENT_BROWSER_GPU_GPU_DATA_MANAGER_IMPL_H_
|
