Add gpu::DomainGuilt to //gpu/config/

It replaces content::GpuDataManagerImpl::DomainGuilt and
viz::GpuHostImpl::Delegate::DomainGuilt.

BUG=709332

Cq-Include-Trybots: luci.chromium.try:android_optional_gpu_tests_rel;luci.chromium.try:linux_optional_gpu_tests_rel;luci.chromium.try:mac_optional_gpu_tests_rel;luci.chromium.try:win_optional_gpu_tests_rel
Change-Id: I5a802e53ec770835954b77ba62e9fe9920377381
Reviewed-on: https://chromium-review.googlesource.com/1201704Reviewed-by: Sadrul Chowdhury <sadrul@chromium.org>
Reviewed-by: Antoine Labour <piman@chromium.org>
Commit-Queue: Mohsen Izadi <mohsen@chromium.org>
Cr-Commit-Position: refs/heads/master@{#589513}

components/viz/host/gpu_host_impl.cc

@@ -187,7 +187,7 @@ void GpuHostImpl::BlockLiveOffscreenContexts() {
 
   for (auto iter = urls_with_live_offscreen_contexts_.begin();
        iter != urls_with_live_offscreen_contexts_.end(); ++iter) {
-    delegate_->BlockDomainFrom3DAPIs(*iter, Delegate::DomainGuilt::kUnknown);
+    delegate_->BlockDomainFrom3DAPIs(*iter, gpu::DomainGuilt::kUnknown);
   }
 }
 
@@ -499,10 +499,10 @@ void GpuHostImpl::DidLoseContext(bool offscreen,
     return;
   }
 
-  Delegate::DomainGuilt guilt = Delegate::DomainGuilt::kUnknown;
+  gpu::DomainGuilt guilt = gpu::DomainGuilt::kUnknown;
   switch (reason) {
     case gpu::error::kGuilty:
-      guilt = Delegate::DomainGuilt::kKnown;
+      guilt = gpu::DomainGuilt::kKnown;
       break;
     // Treat most other error codes as though they had unknown provenance.
     // In practice this doesn't affect the user experience. A lost context

components/viz/host/gpu_host_impl.h

@@ -22,6 +22,7 @@
 #include "components/discardable_memory/public/interfaces/discardable_shared_memory_manager.mojom.h"
 #include "components/viz/host/viz_host_export.h"
 #include "gpu/command_buffer/common/activity_flags.h"
+#include "gpu/config/gpu_domain_guilt.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "mojo/public/cpp/system/message_pipe.h"
 #include "services/viz/privileged/interfaces/compositing/frame_sink_manager.mojom.h"
@@ -49,15 +50,6 @@ class VIZ_HOST_EXPORT GpuHostImpl : public mojom::GpuHost {
  public:
   class VIZ_HOST_EXPORT Delegate {
    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 class DomainGuilt {
-      kKnown,
-      kUnknown,
-    };
-
     virtual gpu::GPUInfo GetGPUInfo() const = 0;
     virtual gpu::GpuFeatureInfo GetGpuFeatureInfo() const = 0;
     virtual void UpdateGpuInfo(
@@ -68,7 +60,8 @@ class VIZ_HOST_EXPORT GpuHostImpl : public mojom::GpuHost {
             gpu_feature_info_for_hardware_gpu) = 0;
     virtual void DidFailInitialize() = 0;
     virtual void DidCreateContextSuccessfully() = 0;
-    virtual void BlockDomainFrom3DAPIs(const GURL& url, DomainGuilt guilt) = 0;
+    virtual void BlockDomainFrom3DAPIs(const GURL& url,
+                                       gpu::DomainGuilt guilt) = 0;
     virtual void DisableGpuCompositing() = 0;
     virtual bool GpuAccessAllowed() const = 0;
     virtual gpu::ShaderCacheFactory* GetShaderCacheFactory() = 0;

content/browser/gpu/gpu_data_manager_impl.cc

@@ -162,8 +162,8 @@ void GpuDataManagerImpl::HandleGpuSwitch() {
   private_->HandleGpuSwitch();
 }
 
-void GpuDataManagerImpl::BlockDomainFrom3DAPIs(
-    const GURL& url, DomainGuilt guilt) {
+void GpuDataManagerImpl::BlockDomainFrom3DAPIs(const GURL& url,
+                                               gpu::DomainGuilt guilt) {
   base::AutoLock auto_lock(lock_);
   private_->BlockDomainFrom3DAPIs(url, guilt);
 }

content/browser/gpu/gpu_data_manager_impl.h

@@ -22,6 +22,7 @@
 #include "content/public/browser/gpu_data_manager.h"
 #include "content/public/common/three_d_api_types.h"
 #include "gpu/config/gpu_control_list.h"
+#include "gpu/config/gpu_domain_guilt.h"
 #include "gpu/config/gpu_feature_info.h"
 #include "gpu/config/gpu_info.h"
 #include "gpu/config/gpu_mode.h"
@@ -43,24 +44,6 @@ class GpuDataManagerImplPrivate;
 
 class CONTENT_EXPORT GpuDataManagerImpl : public 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();
 
@@ -132,7 +115,7 @@ class CONTENT_EXPORT GpuDataManagerImpl : public GpuDataManager {
   //
   // The given URL may be a partial URL (including at least the host)
   // or a full URL to a page.
-  void BlockDomainFrom3DAPIs(const GURL& url, DomainGuilt guilt);
+  void BlockDomainFrom3DAPIs(const GURL& url, gpu::DomainGuilt guilt);
   bool Are3DAPIsBlocked(const GURL& top_origin_url,
                         int render_process_id,
                         int render_frame_id,

content/browser/gpu/gpu_data_manager_impl_private.cc

@@ -705,8 +705,8 @@ bool GpuDataManagerImplPrivate::UpdateActiveGpu(uint32_t vendor_id,
   return true;
 }
 
-void GpuDataManagerImplPrivate::BlockDomainFrom3DAPIs(
-    const GURL& url, GpuDataManagerImpl::DomainGuilt guilt) {
+void GpuDataManagerImplPrivate::BlockDomainFrom3DAPIs(const GURL& url,
+                                                      gpu::DomainGuilt guilt) {
   BlockDomainFrom3DAPIsAtTime(url, guilt, base::Time::Now());
 }
 
@@ -715,7 +715,7 @@ bool GpuDataManagerImplPrivate::Are3DAPIsBlocked(const GURL& top_origin_url,
                                                  int render_frame_id,
                                                  ThreeDAPIType requester) {
   return Are3DAPIsBlockedAtTime(top_origin_url, base::Time::Now()) !=
-         GpuDataManagerImpl::DOMAIN_BLOCK_STATUS_NOT_BLOCKED;
+         DomainBlockStatus::kNotBlocked;
 }
 
 void GpuDataManagerImplPrivate::DisableDomainBlockingFor3DAPIsForTesting() {
@@ -755,35 +755,33 @@ std::string GpuDataManagerImplPrivate::GetDomainFromURL(const GURL& url) const {
 
 void GpuDataManagerImplPrivate::BlockDomainFrom3DAPIsAtTime(
     const GURL& url,
-    GpuDataManagerImpl::DomainGuilt guilt,
+    gpu::DomainGuilt guilt,
     base::Time at_time) {
   if (!domain_blocking_enabled_)
     return;
 
   std::string domain = GetDomainFromURL(url);
 
-  DomainBlockEntry& entry = blocked_domains_[domain];
-  entry.last_guilt = guilt;
+  blocked_domains_[domain] = guilt;
   timestamps_of_gpu_resets_.push_back(at_time);
 }
 
-GpuDataManagerImpl::DomainBlockStatus
-GpuDataManagerImplPrivate::Are3DAPIsBlockedAtTime(
-    const GURL& url, base::Time at_time) const {
+GpuDataManagerImplPrivate::DomainBlockStatus
+GpuDataManagerImplPrivate::Are3DAPIsBlockedAtTime(const GURL& url,
+                                                  base::Time at_time) const {
   if (!domain_blocking_enabled_)
-    return GpuDataManagerImpl::DOMAIN_BLOCK_STATUS_NOT_BLOCKED;
+    return DomainBlockStatus::kNotBlocked;
 
   // Note: adjusting the policies in this code will almost certainly
   // require adjusting the associated unit tests.
   std::string domain = GetDomainFromURL(url);
 
   {
-    DomainBlockMap::const_iterator iter = blocked_domains_.find(domain);
-    if (iter != blocked_domains_.end()) {
+    if (blocked_domains_.find(domain) != blocked_domains_.end()) {
       // Err on the side of caution, and assume that if a particular
       // domain shows up in the block map, it's there for a good
       // reason and don't let its presence there automatically expire.
-      return GpuDataManagerImpl::DOMAIN_BLOCK_STATUS_BLOCKED;
+      return DomainBlockStatus::kBlocked;
     }
   }
 
@@ -816,7 +814,7 @@ GpuDataManagerImplPrivate::Are3DAPIsBlockedAtTime(
                                 BLOCK_STATUS_ALL_DOMAINS_BLOCKED,
                                 BLOCK_STATUS_MAX);
 
-      return GpuDataManagerImpl::DOMAIN_BLOCK_STATUS_ALL_DOMAINS_BLOCKED;
+      return DomainBlockStatus::kAllDomainsBlocked;
     }
   }
 
@@ -824,7 +822,7 @@ GpuDataManagerImplPrivate::Are3DAPIsBlockedAtTime(
                             BLOCK_STATUS_NOT_BLOCKED,
                             BLOCK_STATUS_MAX);
 
-  return GpuDataManagerImpl::DOMAIN_BLOCK_STATUS_NOT_BLOCKED;
+  return DomainBlockStatus::kNotBlocked;
 }
 
 int64_t GpuDataManagerImplPrivate::GetBlockAllDomainsDurationInMs() const {

content/browser/gpu/gpu_data_manager_impl_private.h

@@ -83,8 +83,7 @@ class CONTENT_EXPORT GpuDataManagerImplPrivate {
 
   void HandleGpuSwitch();
 
-  void BlockDomainFrom3DAPIs(
-      const GURL& url, GpuDataManagerImpl::DomainGuilt guilt);
+  void BlockDomainFrom3DAPIs(const GURL& url, gpu::DomainGuilt guilt);
   bool Are3DAPIsBlocked(const GURL& top_origin_url,
                         int render_process_id,
                         int render_frame_id,
@@ -125,11 +124,16 @@ class CONTENT_EXPORT GpuDataManagerImplPrivate {
   FRIEND_TEST_ALL_PREFIXES(GpuDataManagerImplPrivateTest,
                            UnblockThisDomainFrom3DAPIs);
 
-  struct DomainBlockEntry {
-    GpuDataManagerImpl::DomainGuilt last_guilt;
+  // 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 class DomainBlockStatus {
+    kBlocked,
+    kAllDomainsBlocked,
+    kNotBlocked,
   };
 
-  using DomainBlockMap = std::map<std::string, DomainBlockEntry>;
+  using DomainGuiltMap = std::map<std::string, gpu::DomainGuilt>;
 
   using GpuDataManagerObserverList =
       base::ObserverListThreadSafe<GpuDataManagerObserver>;
@@ -157,10 +161,10 @@ class CONTENT_EXPORT GpuDataManagerImplPrivate {
   // Implementation functions for blocking of 3D graphics APIs, used
   // for unit testing.
   void BlockDomainFrom3DAPIsAtTime(const GURL& url,
-                                   GpuDataManagerImpl::DomainGuilt guilt,
+                                   gpu::DomainGuilt guilt,
                                    base::Time at_time);
-  GpuDataManagerImpl::DomainBlockStatus Are3DAPIsBlockedAtTime(
-      const GURL& url, base::Time at_time) const;
+  DomainBlockStatus Are3DAPIsBlockedAtTime(const GURL& url,
+                                           base::Time at_time) const;
   int64_t GetBlockAllDomainsDurationInMs() const;
 
   // This is platform specific. At the moment:
@@ -197,7 +201,7 @@ class CONTENT_EXPORT GpuDataManagerImplPrivate {
   // they cause random failures.
   bool update_histograms_ = true;
 
-  DomainBlockMap blocked_domains_;
+  DomainGuiltMap blocked_domains_;
   mutable std::list<base::Time> timestamps_of_gpu_resets_;
   bool domain_blocking_enabled_ = true;
 

content/browser/gpu/gpu_data_manager_impl_private_unittest.cc

@@ -94,10 +94,8 @@ class GpuDataManagerImplPrivateTest : public testing::Test {
 
   base::Time JustBeforeExpiration(const GpuDataManagerImplPrivate* manager);
   base::Time JustAfterExpiration(const GpuDataManagerImplPrivate* manager);
-  void TestBlockingDomainFrom3DAPIs(
-      GpuDataManagerImpl::DomainGuilt guilt_level);
-  void TestUnblockingDomainFrom3DAPIs(
-      GpuDataManagerImpl::DomainGuilt guilt_level);
+  void TestBlockingDomainFrom3DAPIs(gpu::DomainGuilt guilt_level);
+  void TestUnblockingDomainFrom3DAPIs(gpu::DomainGuilt guilt_level);
 
   base::MessageLoop message_loop_;
 };
@@ -141,7 +139,7 @@ base::Time GpuDataManagerImplPrivateTest::JustAfterExpiration(
 }
 
 void GpuDataManagerImplPrivateTest::TestBlockingDomainFrom3DAPIs(
-    GpuDataManagerImpl::DomainGuilt guilt_level) {
+    gpu::DomainGuilt guilt_level) {
   ScopedGpuDataManagerImplPrivate manager;
 
   manager->BlockDomainFrom3DAPIsAtTime(GetDomain1ForTesting(),
@@ -149,19 +147,19 @@ void GpuDataManagerImplPrivateTest::TestBlockingDomainFrom3DAPIs(
                                       GetTimeForTesting());
 
   // This domain should be blocked no matter what.
-  EXPECT_EQ(GpuDataManagerImpl::DOMAIN_BLOCK_STATUS_BLOCKED,
+  EXPECT_EQ(GpuDataManagerImplPrivate::DomainBlockStatus::kBlocked,
             manager->Are3DAPIsBlockedAtTime(GetDomain1ForTesting(),
                                             GetTimeForTesting()));
-  EXPECT_EQ(GpuDataManagerImpl::DOMAIN_BLOCK_STATUS_BLOCKED,
+  EXPECT_EQ(GpuDataManagerImplPrivate::DomainBlockStatus::kBlocked,
             manager->Are3DAPIsBlockedAtTime(
                 GetDomain1ForTesting(), JustBeforeExpiration(manager.get())));
-  EXPECT_EQ(GpuDataManagerImpl::DOMAIN_BLOCK_STATUS_BLOCKED,
+  EXPECT_EQ(GpuDataManagerImplPrivate::DomainBlockStatus::kBlocked,
             manager->Are3DAPIsBlockedAtTime(
                 GetDomain1ForTesting(), JustAfterExpiration(manager.get())));
 }
 
 void GpuDataManagerImplPrivateTest::TestUnblockingDomainFrom3DAPIs(
-    GpuDataManagerImpl::DomainGuilt guilt_level) {
+    gpu::DomainGuilt guilt_level) {
   ScopedGpuDataManagerImplPrivate manager;
 
   manager->BlockDomainFrom3DAPIsAtTime(GetDomain1ForTesting(),
@@ -170,64 +168,62 @@ void GpuDataManagerImplPrivateTest::TestUnblockingDomainFrom3DAPIs(
 
   // Unblocking the domain should work.
   manager->UnblockDomainFrom3DAPIs(GetDomain1ForTesting());
-  EXPECT_EQ(GpuDataManagerImpl::DOMAIN_BLOCK_STATUS_NOT_BLOCKED,
+  EXPECT_EQ(GpuDataManagerImplPrivate::DomainBlockStatus::kNotBlocked,
             manager->Are3DAPIsBlockedAtTime(GetDomain1ForTesting(),
                                             GetTimeForTesting()));
-  EXPECT_EQ(GpuDataManagerImpl::DOMAIN_BLOCK_STATUS_NOT_BLOCKED,
+  EXPECT_EQ(GpuDataManagerImplPrivate::DomainBlockStatus::kNotBlocked,
             manager->Are3DAPIsBlockedAtTime(
                 GetDomain1ForTesting(), JustBeforeExpiration(manager.get())));
-  EXPECT_EQ(GpuDataManagerImpl::DOMAIN_BLOCK_STATUS_NOT_BLOCKED,
+  EXPECT_EQ(GpuDataManagerImplPrivate::DomainBlockStatus::kNotBlocked,
             manager->Are3DAPIsBlockedAtTime(
                 GetDomain1ForTesting(), JustAfterExpiration(manager.get())));
 }
 
 TEST_F(GpuDataManagerImplPrivateTest, BlockGuiltyDomainFrom3DAPIs) {
-  TestBlockingDomainFrom3DAPIs(GpuDataManagerImpl::DOMAIN_GUILT_KNOWN);
+  TestBlockingDomainFrom3DAPIs(gpu::DomainGuilt::kKnown);
 }
 
 TEST_F(GpuDataManagerImplPrivateTest, BlockDomainOfUnknownGuiltFrom3DAPIs) {
-  TestBlockingDomainFrom3DAPIs(GpuDataManagerImpl::DOMAIN_GUILT_UNKNOWN);
+  TestBlockingDomainFrom3DAPIs(gpu::DomainGuilt::kUnknown);
 }
 
 TEST_F(GpuDataManagerImplPrivateTest, BlockAllDomainsFrom3DAPIs) {
   ScopedGpuDataManagerImplPrivate manager;
 
-  manager->BlockDomainFrom3DAPIsAtTime(GetDomain1ForTesting(),
-                                       GpuDataManagerImpl::DOMAIN_GUILT_UNKNOWN,
-                                       GetTimeForTesting());
+  manager->BlockDomainFrom3DAPIsAtTime(
+      GetDomain1ForTesting(), gpu::DomainGuilt::kUnknown, GetTimeForTesting());
 
   // Blocking of other domains should expire.
-  EXPECT_EQ(GpuDataManagerImpl::DOMAIN_BLOCK_STATUS_ALL_DOMAINS_BLOCKED,
+  EXPECT_EQ(GpuDataManagerImplPrivate::DomainBlockStatus::kAllDomainsBlocked,
             manager->Are3DAPIsBlockedAtTime(
                 GetDomain2ForTesting(), JustBeforeExpiration(manager.get())));
-  EXPECT_EQ(GpuDataManagerImpl::DOMAIN_BLOCK_STATUS_NOT_BLOCKED,
+  EXPECT_EQ(GpuDataManagerImplPrivate::DomainBlockStatus::kNotBlocked,
             manager->Are3DAPIsBlockedAtTime(
                 GetDomain2ForTesting(), JustAfterExpiration(manager.get())));
 }
 
 TEST_F(GpuDataManagerImplPrivateTest, UnblockGuiltyDomainFrom3DAPIs) {
-  TestUnblockingDomainFrom3DAPIs(GpuDataManagerImpl::DOMAIN_GUILT_KNOWN);
+  TestUnblockingDomainFrom3DAPIs(gpu::DomainGuilt::kKnown);
 }
 
 TEST_F(GpuDataManagerImplPrivateTest, UnblockDomainOfUnknownGuiltFrom3DAPIs) {
-  TestUnblockingDomainFrom3DAPIs(GpuDataManagerImpl::DOMAIN_GUILT_UNKNOWN);
+  TestUnblockingDomainFrom3DAPIs(gpu::DomainGuilt::kUnknown);
 }
 
 TEST_F(GpuDataManagerImplPrivateTest, UnblockOtherDomainFrom3DAPIs) {
   ScopedGpuDataManagerImplPrivate manager;
 
-  manager->BlockDomainFrom3DAPIsAtTime(GetDomain1ForTesting(),
-                                       GpuDataManagerImpl::DOMAIN_GUILT_UNKNOWN,
-                                       GetTimeForTesting());
+  manager->BlockDomainFrom3DAPIsAtTime(
+      GetDomain1ForTesting(), gpu::DomainGuilt::kUnknown, GetTimeForTesting());
 
   manager->UnblockDomainFrom3DAPIs(GetDomain2ForTesting());
 
-  EXPECT_EQ(GpuDataManagerImpl::DOMAIN_BLOCK_STATUS_NOT_BLOCKED,
+  EXPECT_EQ(GpuDataManagerImplPrivate::DomainBlockStatus::kNotBlocked,
             manager->Are3DAPIsBlockedAtTime(
                 GetDomain2ForTesting(), JustBeforeExpiration(manager.get())));
 
   // The original domain should still be blocked.
-  EXPECT_EQ(GpuDataManagerImpl::DOMAIN_BLOCK_STATUS_BLOCKED,
+  EXPECT_EQ(GpuDataManagerImplPrivate::DomainBlockStatus::kBlocked,
             manager->Are3DAPIsBlockedAtTime(
                 GetDomain1ForTesting(), JustBeforeExpiration(manager.get())));
 }
@@ -235,15 +231,14 @@ TEST_F(GpuDataManagerImplPrivateTest, UnblockOtherDomainFrom3DAPIs) {
 TEST_F(GpuDataManagerImplPrivateTest, UnblockThisDomainFrom3DAPIs) {
   ScopedGpuDataManagerImplPrivate manager;
 
-  manager->BlockDomainFrom3DAPIsAtTime(GetDomain1ForTesting(),
-                                       GpuDataManagerImpl::DOMAIN_GUILT_UNKNOWN,
-                                       GetTimeForTesting());
+  manager->BlockDomainFrom3DAPIsAtTime(
+      GetDomain1ForTesting(), gpu::DomainGuilt::kUnknown, GetTimeForTesting());
 
   manager->UnblockDomainFrom3DAPIs(GetDomain1ForTesting());
 
   // This behavior is debatable. Perhaps the GPU reset caused by
   // domain 1 should still cause other domains to be blocked.
-  EXPECT_EQ(GpuDataManagerImpl::DOMAIN_BLOCK_STATUS_NOT_BLOCKED,
+  EXPECT_EQ(GpuDataManagerImplPrivate::DomainBlockStatus::kNotBlocked,
             manager->Are3DAPIsBlockedAtTime(
                 GetDomain2ForTesting(), JustBeforeExpiration(manager.get())));
 }

content/browser/gpu/gpu_process_host.cc

@@ -945,17 +945,9 @@ void GpuProcessHost::DidCreateContextSuccessfully() {
 #endif
 }
 
-void GpuProcessHost::BlockDomainFrom3DAPIs(const GURL& url, DomainGuilt guilt) {
-  GpuDataManagerImpl::DomainGuilt gpu_data_manager_guilt;
-  switch (guilt) {
-    case DomainGuilt::kKnown:
-      gpu_data_manager_guilt = GpuDataManagerImpl::DOMAIN_GUILT_KNOWN;
-      break;
-    case DomainGuilt::kUnknown:
-      gpu_data_manager_guilt = GpuDataManagerImpl::DOMAIN_GUILT_UNKNOWN;
-  }
-  GpuDataManagerImpl::GetInstance()->BlockDomainFrom3DAPIs(
-      url, gpu_data_manager_guilt);
+void GpuProcessHost::BlockDomainFrom3DAPIs(const GURL& url,
+                                           gpu::DomainGuilt guilt) {
+  GpuDataManagerImpl::GetInstance()->BlockDomainFrom3DAPIs(url, guilt);
 }
 
 bool GpuProcessHost::GpuAccessAllowed() const {

content/browser/gpu/gpu_process_host.h

@@ -144,7 +144,7 @@ class GpuProcessHost : public BrowserChildProcessHostDelegate,
           gpu_feature_info_for_hardware_gpu) override;
   void DidFailInitialize() override;
   void DidCreateContextSuccessfully() override;
-  void BlockDomainFrom3DAPIs(const GURL& url, DomainGuilt guilt) override;
+  void BlockDomainFrom3DAPIs(const GURL& url, gpu::DomainGuilt guilt) override;
   void DisableGpuCompositing() override;
   bool GpuAccessAllowed() const override;
   gpu::ShaderCacheFactory* GetShaderCacheFactory() override;

gpu/config/BUILD.gn

@@ -102,6 +102,7 @@ source_set("config_sources") {
     "gpu_control_list.h",
     "gpu_crash_keys.cc",
     "gpu_crash_keys.h",
+    "gpu_domain_guilt.h",
     "gpu_driver_bug_list.cc",
     "gpu_driver_bug_list.h",
     "gpu_driver_bug_workaround_type.h",

gpu/config/gpu_domain_guilt.h

+// Copyright 2018 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 GPU_CONFIG_GPU_DOMAIN_GUILT_H_
+#define GPU_CONFIG_GPU_DOMAIN_GUILT_H_
+
+namespace gpu {
+
+// 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 class DomainGuilt {
+  kKnown,
+  kUnknown,
+};
+
+}  // namespace gpu
+
+#endif  // GPU_CONFIG_GPU_DOMAIN_GUILT_H_