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#ifndef CONTENT_BROWSER_GPU_GPU_DATA_MANAGER_IMPL_H_
6#define CONTENT_BROWSER_GPU_GPU_DATA_MANAGER_IMPL_H_
7
8#include <string>
9
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"
24
25class GURL;
26
27namespace base {
28class CommandLine;
29}
30
31namespace content {
32
33class GpuDataManagerImplPrivate;
34struct WebPreferences;
35
36class CONTENT_EXPORT GpuDataManagerImpl
37    : public NON_EXPORTED_BASE(GpuDataManager) {
38 public:
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.
43  enum DomainGuilt {
44    DOMAIN_GUILT_KNOWN,
45    DOMAIN_GUILT_UNKNOWN
46  };
47
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
55  };
56
57  // Getter for the singleton. This will return NULL on failure.
58  static GpuDataManagerImpl* GetInstance();
59
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;
88
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.
92  void Initialize();
93
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);
97
98  void UpdateVideoMemoryUsageStats(
99      const GPUVideoMemoryUsageStats& video_memory_usage_stats);
100
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;
104
105  // Insert switches into gpu process command line: kUseGL, etc.
106  void AppendGpuCommandLine(base::CommandLine* command_line) const;
107
108  // Insert switches into plugin process command line:
109  // kDisableCoreAnimationPlugins.
110  void AppendPluginCommandLine(base::CommandLine* command_line) const;
111
112  // Update WebPreferences for renderer based on blacklisting decisions.
113  void UpdateRendererWebPrefs(WebPreferences* prefs) const;
114
115  std::string GetBlacklistVersion() const;
116  std::string GetDriverBugListVersion() const;
117
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;
122
123  // Returns the workarounds that are applied to the current system as
124  // a list of strings.
125  void GetDriverBugWorkarounds(base::ListValue* workarounds) const;
126
127  void AddLogMessage(int level,
128                     const std::string& header,
129                     const std::string& message);
130
131  void ProcessCrashed(base::TerminationStatus exit_code);
132
133  // Returns a new copy of the ListValue.  Caller is responsible to release
134  // the returned value.
135  base::ListValue* GetLogMessages() const;
136
137  // Called when switching gpu.
138  void HandleGpuSwitch();
139
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.
145  //
146  // The given URL may be a partial URL (including at least the host)
147  // or a full URL to a page.
148  //
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,
154                        int render_view_id,
155                        ThreeDAPIType requester);
156
157  // Disables domain blocking for 3D APIs. For use only in tests.
158  void DisableDomainBlockingFor3DAPIsForTesting();
159
160  void Notify3DAPIBlocked(const GURL& url,
161                          int render_process_id,
162                          int render_view_id,
163                          ThreeDAPIType requester);
164
165  // Get number of features being blacklisted.
166  size_t GetBlacklistedFeatureCount() const;
167
168  void SetDisplayCount(unsigned int display_count);
169  unsigned int GetDisplayCount() const;
170
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);
174
175  // Called when GPU process initialization failed.
176  void OnGpuProcessInitFailure();
177
178  bool IsDriverBugWorkaroundActive(int feature) const;
179
180 private:
181  friend class GpuDataManagerImplPrivate;
182  friend class GpuDataManagerImplPrivateTest;
183  friend struct DefaultSingletonTraits<GpuDataManagerImpl>;
184
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 {
191   public:
192    explicit UnlockedSession(GpuDataManagerImpl* owner)
193        : owner_(owner) {
194      DCHECK(owner_);
195      owner_->lock_.AssertAcquired();
196      owner_->lock_.Release();
197    }
198
199    ~UnlockedSession() {
200      DCHECK(owner_);
201      owner_->lock_.Acquire();
202    }
203
204   private:
205    GpuDataManagerImpl* owner_;
206    DISALLOW_COPY_AND_ASSIGN(UnlockedSession);
207  };
208
209  GpuDataManagerImpl();
210  virtual ~GpuDataManagerImpl();
211
212  mutable base::Lock lock_;
213  scoped_ptr<GpuDataManagerImplPrivate> private_;
214
215  DISALLOW_COPY_AND_ASSIGN(GpuDataManagerImpl);
216};
217
218}  // namespace content
219
220#endif  // CONTENT_BROWSER_GPU_GPU_DATA_MANAGER_IMPL_H_
221