Add logic to block the use of client 3D APIs (WebGL, Pepper 3D) if context lost notifications are r…

content/browser/gpu/gpu_data_manager_impl_unittest.cc

Index: content/browser/gpu/gpu_data_manager_impl_unittest.cc
diff --git a/content/browser/gpu/gpu_data_manager_impl_unittest.cc b/content/browser/gpu/gpu_data_manager_impl_unittest.cc
index 371f60721f4b5b041005c6e6795e6c30143d79d9..fa75b3af13813136788fc1560411d194599e6461 100644
--- a/content/browser/gpu/gpu_data_manager_impl_unittest.cc
+++ b/content/browser/gpu/gpu_data_manager_impl_unittest.cc
@@ -2,11 +2,14 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/run_loop.h"
+#include "base/time.h"
 #include "content/browser/gpu/gpu_data_manager_impl.h"
 #include "content/public/browser/gpu_data_manager_observer.h"
 #include "content/public/common/gpu_info.h"
+#include "googleurl/src/gurl.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
@@ -39,6 +42,18 @@ class TestObserver : public GpuDataManagerObserver {
   bool video_memory_usage_stats_updated_;
 };
 
+static base::Time GetTimeForTesting() {
+  return base::Time::FromDoubleT(1000);
+}
+
+static GURL GetDomain1ForTesting() {
+  return GURL("http://foo.com/");
+}
+
+static GURL GetDomain2ForTesting() {
+  return GURL("http://bar.com/");
+}
+
 }  // namespace anonymous
 
 class GpuDataManagerImplTest : public testing::Test {
@@ -48,12 +63,38 @@ class GpuDataManagerImplTest : public testing::Test {
   virtual ~GpuDataManagerImplTest() { }
 
  protected:
+  // scoped_ptr doesn't work with GpuDataManagerImpl because its
+  // destructor is private. GpuDataManagerImplTest is however a friend
+  // so we can make a little helper class here.
+  class ScopedGpuDataManagerImpl {
+   public:
+    ScopedGpuDataManagerImpl() : impl_(new GpuDataManagerImpl()) {}
+    ~ScopedGpuDataManagerImpl() { delete impl_; }
+
+    GpuDataManagerImpl* get() const { return impl_; }
+    GpuDataManagerImpl* operator->() const { return impl_; }
+    // Small violation of C++ style guide to avoid polluting several
+    // tests with get() calls.
+    operator GpuDataManagerImpl*() { return impl_; }
+
+   private:
+    GpuDataManagerImpl* impl_;
+    DISALLOW_COPY_AND_ASSIGN(ScopedGpuDataManagerImpl);
+  };
+
   void SetUp() {
   }
 
   void TearDown() {
   }
 
+  base::Time JustBeforeExpiration(GpuDataManagerImpl* manager);
+  base::Time JustAfterExpiration(GpuDataManagerImpl* manager);
+  void TestBlockingDomainFrom3DAPIs(
+      GpuDataManager::DomainGuilt guilt_level);
+  void TestUnblockingDomainFrom3DAPIs(
+      GpuDataManager::DomainGuilt guilt_level);
+
   MessageLoop message_loop_;
 };
 
@@ -65,8 +106,8 @@ TEST_F(GpuDataManagerImplTest, GpuSideBlacklisting) {
   // disabled when GPU process launches and collects full GPU info,
   // it's too late to let renderer know, so we basically block all GPU
   // access, to be on the safe side.
-  GpuDataManagerImpl* manager = new GpuDataManagerImpl();
-  ASSERT_TRUE(manager);
+  ScopedGpuDataManagerImpl manager;
+  ASSERT_TRUE(manager.get());
   EXPECT_EQ(0, manager->GetBlacklistedFeatures());
   EXPECT_TRUE(manager->GpuAccessAllowed());
 
@@ -108,13 +149,11 @@ TEST_F(GpuDataManagerImplTest, GpuSideBlacklisting) {
   EXPECT_EQ(GPU_FEATURE_TYPE_WEBGL |
             GPU_FEATURE_TYPE_ACCELERATED_2D_CANVAS,
             manager->GetBlacklistedFeatures());
-
-  delete manager;
 }
 
 TEST_F(GpuDataManagerImplTest, GpuSideExceptions) {
-  GpuDataManagerImpl* manager = new GpuDataManagerImpl();
-  ASSERT_TRUE(manager);
+  ScopedGpuDataManagerImpl manager;
+  ASSERT_TRUE(manager.get());
   EXPECT_EQ(0, manager->GetBlacklistedFeatures());
   EXPECT_TRUE(manager->GpuAccessAllowed());
 
@@ -153,27 +192,23 @@ TEST_F(GpuDataManagerImplTest, GpuSideExceptions) {
   manager->UpdateGpuInfo(gpu_info);
   EXPECT_TRUE(manager->GpuAccessAllowed());
   EXPECT_EQ(0, manager->GetBlacklistedFeatures());
-
-  delete manager;
 }
 
 TEST_F(GpuDataManagerImplTest, BlacklistCard) {
-  GpuDataManagerImpl* manager = new GpuDataManagerImpl();
-  ASSERT_TRUE(manager);
+  ScopedGpuDataManagerImpl manager;
+  ASSERT_TRUE(manager.get());
   EXPECT_EQ(0, manager->GetBlacklistedFeatures());
   EXPECT_TRUE(manager->GpuAccessAllowed());
 
   manager->BlacklistCard();
   EXPECT_FALSE(manager->GpuAccessAllowed());
   EXPECT_EQ(GPU_FEATURE_TYPE_ALL, manager->GetBlacklistedFeatures());
-
-  delete manager;
 }
 
 TEST_F(GpuDataManagerImplTest, SoftwareRendering) {
   // Blacklist, then register SwiftShader.
-  GpuDataManagerImpl* manager = new GpuDataManagerImpl();
-  ASSERT_TRUE(manager);
+  ScopedGpuDataManagerImpl manager;
+  ASSERT_TRUE(manager.get());
   EXPECT_EQ(0, manager->GetBlacklistedFeatures());
   EXPECT_TRUE(manager->GpuAccessAllowed());
   EXPECT_FALSE(manager->ShouldUseSoftwareRendering());
@@ -190,14 +225,12 @@ TEST_F(GpuDataManagerImplTest, SoftwareRendering) {
   EXPECT_TRUE(manager->GpuAccessAllowed());
   EXPECT_EQ(GPU_FEATURE_TYPE_ACCELERATED_2D_CANVAS,
             manager->GetBlacklistedFeatures());
-
-  delete manager;
 }
 
 TEST_F(GpuDataManagerImplTest, SoftwareRendering2) {
   // Register SwiftShader, then blacklist.
-  GpuDataManagerImpl* manager = new GpuDataManagerImpl();
-  ASSERT_TRUE(manager);
+  ScopedGpuDataManagerImpl manager;
+  ASSERT_TRUE(manager.get());
   EXPECT_EQ(0, manager->GetBlacklistedFeatures());
   EXPECT_TRUE(manager->GpuAccessAllowed());
   EXPECT_FALSE(manager->ShouldUseSoftwareRendering());
@@ -213,13 +246,11 @@ TEST_F(GpuDataManagerImplTest, SoftwareRendering2) {
   EXPECT_TRUE(manager->ShouldUseSoftwareRendering());
   EXPECT_EQ(GPU_FEATURE_TYPE_ACCELERATED_2D_CANVAS,
             manager->GetBlacklistedFeatures());
-
-  delete manager;
 }
 
 TEST_F(GpuDataManagerImplTest, GpuInfoUpdate) {
-  GpuDataManagerImpl* manager = new GpuDataManagerImpl();
-  ASSERT_TRUE(manager);
+  ScopedGpuDataManagerImpl manager;
+  ASSERT_TRUE(manager.get());
 
   TestObserver observer;
   manager->AddObserver(&observer);
@@ -237,13 +268,11 @@ TEST_F(GpuDataManagerImplTest, GpuInfoUpdate) {
     run_loop.RunUntilIdle();
   }
   EXPECT_TRUE(observer.gpu_info_updated());
-
-  delete manager;
 }
 
 TEST_F(GpuDataManagerImplTest, NoGpuInfoUpdateWithSoftwareRendering) {
-  GpuDataManagerImpl* manager = new GpuDataManagerImpl();
-  ASSERT_TRUE(manager);
+  ScopedGpuDataManagerImpl manager;
+  ASSERT_TRUE(manager.get());
 
   manager->BlacklistCard();
   const FilePath test_path(FILE_PATH_LITERAL("AnyPath"));
@@ -271,13 +300,11 @@ TEST_F(GpuDataManagerImplTest, NoGpuInfoUpdateWithSoftwareRendering) {
     run_loop.RunUntilIdle();
   }
   EXPECT_FALSE(observer.gpu_info_updated());
-
-  delete manager;
 }
 
 TEST_F(GpuDataManagerImplTest, GPUVideoMemoryUsageStatsUpdate) {
-  GpuDataManagerImpl* manager = new GpuDataManagerImpl();
-  ASSERT_TRUE(manager);
+  ScopedGpuDataManagerImpl manager;
+  ASSERT_TRUE(manager.get());
 
   TestObserver observer;
   manager->AddObserver(&observer);
@@ -295,8 +322,133 @@ TEST_F(GpuDataManagerImplTest, GPUVideoMemoryUsageStatsUpdate) {
     run_loop.RunUntilIdle();
   }
   EXPECT_TRUE(observer.video_memory_usage_stats_updated());
+}
+
+base::Time GpuDataManagerImplTest::JustBeforeExpiration(
+    GpuDataManagerImpl* manager) {
+  return GetTimeForTesting() + base::TimeDelta::FromMilliseconds(
+      manager->GetBlockAllDomainsDurationInMs()) -
+      base::TimeDelta::FromMilliseconds(3);
+}
+
+base::Time GpuDataManagerImplTest::JustAfterExpiration(
+    GpuDataManagerImpl* manager) {
+  return GetTimeForTesting() + base::TimeDelta::FromMilliseconds(
+      manager->GetBlockAllDomainsDurationInMs()) +
+      base::TimeDelta::FromMilliseconds(3);
+}
+
+void GpuDataManagerImplTest::TestBlockingDomainFrom3DAPIs(
+    GpuDataManager::DomainGuilt guilt_level) {
+  ScopedGpuDataManagerImpl manager;
+  ASSERT_TRUE(manager.get());
+
+  manager->BlockDomainFrom3DAPIsAtTime(GetDomain1ForTesting(),
+                                       guilt_level,
+                                       GetTimeForTesting());
+
+  // This domain should be blocked no matter what.
+  EXPECT_EQ(GpuDataManager::DOMAIN_BLOCK_STATUS_BLOCKED,
+            manager->Are3DAPIsBlockedAtTime(GetDomain1ForTesting(),
+                                            GetTimeForTesting()));
+  EXPECT_EQ(GpuDataManager::DOMAIN_BLOCK_STATUS_BLOCKED,
+            manager->Are3DAPIsBlockedAtTime(GetDomain1ForTesting(),
+                                            JustBeforeExpiration(manager)));
+  EXPECT_EQ(GpuDataManager::DOMAIN_BLOCK_STATUS_BLOCKED,
+            manager->Are3DAPIsBlockedAtTime(GetDomain1ForTesting(),
+                                            JustAfterExpiration(manager)));
+}
+
+void GpuDataManagerImplTest::TestUnblockingDomainFrom3DAPIs(
+    GpuDataManager::DomainGuilt guilt_level) {
+  ScopedGpuDataManagerImpl manager;
+  ASSERT_TRUE(manager.get());
+
+  manager->BlockDomainFrom3DAPIsAtTime(GetDomain1ForTesting(),
+                                       guilt_level,
+                                       GetTimeForTesting());
+
+  // Unblocking the domain should work.
+  manager->UnblockDomainFrom3DAPIs(GetDomain1ForTesting());
+  EXPECT_EQ(GpuDataManager::DOMAIN_BLOCK_STATUS_NOT_BLOCKED,
+            manager->Are3DAPIsBlockedAtTime(GetDomain1ForTesting(),
+                                            GetTimeForTesting()));
+  EXPECT_EQ(GpuDataManager::DOMAIN_BLOCK_STATUS_NOT_BLOCKED,
+            manager->Are3DAPIsBlockedAtTime(GetDomain1ForTesting(),
+                                            JustBeforeExpiration(manager)));
+  EXPECT_EQ(GpuDataManager::DOMAIN_BLOCK_STATUS_NOT_BLOCKED,
+            manager->Are3DAPIsBlockedAtTime(GetDomain1ForTesting(),
+                                            JustAfterExpiration(manager)));
+}
+
+TEST_F(GpuDataManagerImplTest, BlockGuiltyDomainFrom3DAPIs) {
+  TestBlockingDomainFrom3DAPIs(GpuDataManager::DOMAIN_GUILT_KNOWN);
+}
+
+TEST_F(GpuDataManagerImplTest, BlockDomainOfUnknownGuiltFrom3DAPIs) {
+  TestBlockingDomainFrom3DAPIs(GpuDataManager::DOMAIN_GUILT_UNKNOWN);
+}
+
+TEST_F(GpuDataManagerImplTest, BlockAllDomainsFrom3DAPIs) {
+  ScopedGpuDataManagerImpl manager;
+  ASSERT_TRUE(manager.get());
+
+  manager->BlockDomainFrom3DAPIsAtTime(GetDomain1ForTesting(),
+                                       GpuDataManager::DOMAIN_GUILT_UNKNOWN,
+                                       GetTimeForTesting());
+
+  // Blocking of other domains should expire.
+  EXPECT_EQ(GpuDataManager::DOMAIN_BLOCK_STATUS_ALL_DOMAINS_BLOCKED,
+            manager->Are3DAPIsBlockedAtTime(GetDomain2ForTesting(),
+                                            JustBeforeExpiration(manager)));
+  EXPECT_EQ(GpuDataManager::DOMAIN_BLOCK_STATUS_NOT_BLOCKED,
+            manager->Are3DAPIsBlockedAtTime(GetDomain2ForTesting(),
+                                            JustAfterExpiration(manager)));
+}
+
+TEST_F(GpuDataManagerImplTest, UnblockGuiltyDomainFrom3DAPIs) {
+  TestUnblockingDomainFrom3DAPIs(GpuDataManager::DOMAIN_GUILT_KNOWN);
+}
+
+TEST_F(GpuDataManagerImplTest, UnblockDomainOfUnknownGuiltFrom3DAPIs) {
+  TestUnblockingDomainFrom3DAPIs(GpuDataManager::DOMAIN_GUILT_UNKNOWN);
+}
+
+TEST_F(GpuDataManagerImplTest, UnblockOtherDomainFrom3DAPIs) {
+  ScopedGpuDataManagerImpl manager;
+  ASSERT_TRUE(manager.get());
+
+  manager->BlockDomainFrom3DAPIsAtTime(GetDomain1ForTesting(),
+                                       GpuDataManager::DOMAIN_GUILT_UNKNOWN,
+                                       GetTimeForTesting());
+
+  manager->UnblockDomainFrom3DAPIs(GetDomain2ForTesting());
+
+  EXPECT_EQ(GpuDataManager::DOMAIN_BLOCK_STATUS_NOT_BLOCKED,
+            manager->Are3DAPIsBlockedAtTime(GetDomain2ForTesting(),
+                                            JustBeforeExpiration(manager)));
+
+  // The original domain should still be blocked.
+  EXPECT_EQ(GpuDataManager::DOMAIN_BLOCK_STATUS_BLOCKED,
+            manager->Are3DAPIsBlockedAtTime(GetDomain1ForTesting(),
+                                            JustBeforeExpiration(manager)));
+}
+
+TEST_F(GpuDataManagerImplTest, UnblockThisDomainFrom3DAPIs) {
+  ScopedGpuDataManagerImpl manager;
+  ASSERT_TRUE(manager.get());
+
+  manager->BlockDomainFrom3DAPIsAtTime(GetDomain1ForTesting(),
+                                       GpuDataManager::DOMAIN_GUILT_UNKNOWN,
+                                       GetTimeForTesting());
+
+  manager->UnblockDomainFrom3DAPIs(GetDomain1ForTesting());
 
-  delete manager;
+  // This behavior is debatable. Perhaps the GPU reset caused by
+  // domain 1 should still cause other domains to be blocked.
+  EXPECT_EQ(GpuDataManager::DOMAIN_BLOCK_STATUS_NOT_BLOCKED,
+            manager->Are3DAPIsBlockedAtTime(GetDomain2ForTesting(),
+                                            JustBeforeExpiration(manager)));
 }
 
 }  // namespace content