content/browser/gpu/gpu_data_manager_impl.h

   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
  25 class CommandLine;
  26 class GURL;
  27 struct WebPreferences;
  28
  29 namespace content {
  30
  31 class GpuDataManagerImplPrivate;
  32
  33 class CONTENT_EXPORT GpuDataManagerImpl
  34     : public NON_EXPORTED_BASE(GpuDataManager) {
  35  public:
  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.
  40   enum DomainGuilt {
  41     DOMAIN_GUILT_KNOWN,
  42     DOMAIN_GUILT_UNKNOWN
  43   };
  44
  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
  52   };
  53
  54   // Getter for the singleton. This will return NULL on failure.
  55   static GpuDataManagerImpl* GetInstance();
  56
  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;
  83
  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.
  87   void Initialize();
  88
  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);
  92
  93   void UpdateVideoMemoryUsageStats(
  94       const GPUVideoMemoryUsageStats& video_memory_usage_stats);
  95
  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;
  99
 100   // Insert switches into gpu process command line: kUseGL,
 101   // kDisableGLMultisampling.
 102   void AppendGpuCommandLine(CommandLine* command_line) const;
 103
 104   // Insert switches into plugin process command line:
 105   // kDisableCoreAnimationPlugins.
 106   void AppendPluginCommandLine(CommandLine* command_line) const;
 107
 108   // Update WebPreferences for renderer based on blacklisting decisions.
 109   void UpdateRendererWebPrefs(WebPreferences* prefs) const;
 110
 111   std::string GetBlacklistVersion() const;
 112   std::string GetDriverBugListVersion() const;
 113
 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;
 118
 119   // Returns the workarounds that are applied to the current system as
 120   // a list of strings.
 121   void GetDriverBugWorkarounds(base::ListValue* workarounds) const;
 122
 123   void AddLogMessage(int level,
 124                      const std::string& header,
 125                      const std::string& message);
 126
 127   void ProcessCrashed(base::TerminationStatus exit_code);
 128
 129   // Returns a new copy of the ListValue.  Caller is responsible to release
 130   // the returned value.
 131   base::ListValue* GetLogMessages() const;
 132
 133   // Called when switching gpu.
 134   void HandleGpuSwitch();
 135
 136 #if defined(OS_WIN)
 137   // Is the GPU process using the accelerated surface to present, instead of
 138   // presenting by itself.
 139   bool IsUsingAcceleratedSurface() const;
 140 #endif
 141
 142   // Maintenance of domains requiring explicit user permission before
 143   // using client-facing 3D APIs (WebGL, Pepper 3D), either because
 144   // the domain has caused the GPU to reset, or because too many GPU
 145   // resets have been observed globally recently, and system stability
 146   // might be compromised.
 147   //
 148   // The given URL may be a partial URL (including at least the host)
 149   // or a full URL to a page.
 150   //
 151   // Note that the unblocking API must be part of the content API
 152   // because it is called from Chrome side code.
 153   void BlockDomainFrom3DAPIs(const GURL& url, DomainGuilt guilt);
 154   bool Are3DAPIsBlocked(const GURL& url,
 155                         int render_process_id,
 156                         int render_view_id,
 157                         ThreeDAPIType requester);
 158
 159   // Disables domain blocking for 3D APIs. For use only in tests.
 160   void DisableDomainBlockingFor3DAPIsForTesting();
 161
 162   void Notify3DAPIBlocked(const GURL& url,
 163                           int render_process_id,
 164                           int render_view_id,
 165                           ThreeDAPIType requester);
 166
 167   // Get number of features being blacklisted.
 168   size_t GetBlacklistedFeatureCount() const;
 169
 170   void SetDisplayCount(unsigned int display_count);
 171   unsigned int GetDisplayCount() const;
 172
 173   // Called when GPU process initialization failed.
 174   void OnGpuProcessInitFailure();
 175
 176   bool IsDriverBugWorkaroundActive(int feature) const;
 177
 178  private:
 179   friend class GpuDataManagerImplPrivate;
 180   friend class GpuDataManagerImplPrivateTest;
 181   friend struct DefaultSingletonTraits<GpuDataManagerImpl>;
 182
 183   // It's similar to AutoUnlock, but we want to make it a no-op
 184   // if the owner GpuDataManagerImpl is null.
 185   // This should only be used by GpuDataManagerImplPrivate where
 186   // callbacks are called, during which re-entering
 187   // GpuDataManagerImpl is possible.
 188   class UnlockedSession {
 189    public:
 190     explicit UnlockedSession(GpuDataManagerImpl* owner)
 191         : owner_(owner) {
 192       DCHECK(owner_);
 193       owner_->lock_.AssertAcquired();
 194       owner_->lock_.Release();
 195     }
 196
 197     ~UnlockedSession() {
 198       DCHECK(owner_);
 199       owner_->lock_.Acquire();
 200     }
 201
 202    private:
 203     GpuDataManagerImpl* owner_;
 204     DISALLOW_COPY_AND_ASSIGN(UnlockedSession);
 205   };
 206
 207   GpuDataManagerImpl();
 208   virtual ~GpuDataManagerImpl();
 209
 210   mutable base::Lock lock_;
 211   scoped_ptr<GpuDataManagerImplPrivate> private_;
 212
 213   DISALLOW_COPY_AND_ASSIGN(GpuDataManagerImpl);
 214 };
 215
 216 }  // namespace content
 217
 218 #endif  // CONTENT_BROWSER_GPU_GPU_DATA_MANAGER_IMPL_H_