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

 // Copyright (c) 2012 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.
 
+#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 {
 namespace {
 
 class TestObserver : public GpuDataManagerObserver {
  public:
   TestObserver()
       : gpu_info_updated_(false),
         video_memory_usage_stats_updated_(false) {
@@ skipping 12 matching lines @@
   virtual void OnVideoMemoryUsageStatsUpdate(
       const GPUVideoMemoryUsageStats& stats) OVERRIDE {
     video_memory_usage_stats_updated_ = true;
   }
 
  private:
   bool gpu_info_updated_;
   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 {
  public:
   GpuDataManagerImplTest() { }
 
   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_;
 };
 
 // We use new method instead of GetInstance() method because we want
 // each test to be independent of each other.
 
 TEST_F(GpuDataManagerImplTest, GpuSideBlacklisting) {
   // If a feature is allowed in preliminary step (browser side), but
   // 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());
 
   const std::string blacklist_json =
       "{\n"
       "  \"name\": \"gpu blacklist\",\n"
       "  \"version\": \"0.1\",\n"
       "  \"entries\": [\n"
       "    {\n"
       "      \"id\": 1,\n"
@@ skipping 21 matching lines @@
 
   EXPECT_TRUE(manager->GpuAccessAllowed());
   EXPECT_EQ(GPU_FEATURE_TYPE_WEBGL, manager->GetBlacklistedFeatures());
 
   gpu_info.gl_renderer = "NVIDIA GeForce GT 120";
   manager->UpdateGpuInfo(gpu_info);
   EXPECT_FALSE(manager->GpuAccessAllowed());
   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());
 
   const std::string blacklist_json =
       "{\n"
       "  \"name\": \"gpu blacklist\",\n"
       "  \"version\": \"0.1\",\n"
       "  \"entries\": [\n"
       "    {\n"
       "      \"id\": 1,\n"
@@ skipping 18 matching lines @@
   manager->InitializeForTesting(blacklist_json, gpu_info);
 
   EXPECT_TRUE(manager->GpuAccessAllowed());
   EXPECT_EQ(0, manager->GetBlacklistedFeatures());
 
   // Now assue gpu process launches and full GPU info is collected.
   gpu_info.gl_renderer = "NVIDIA GeForce GT 120";
   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());
 
   manager->BlacklistCard();
   EXPECT_FALSE(manager->GpuAccessAllowed());
   EXPECT_FALSE(manager->ShouldUseSoftwareRendering());
 
   // If software rendering is enabled, even if we blacklist GPU,
   // GPU process is still allowed.
   const FilePath test_path(FILE_PATH_LITERAL("AnyPath"));
   manager->RegisterSwiftShaderPath(test_path);
   EXPECT_TRUE(manager->ShouldUseSoftwareRendering());
   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());
 
   const FilePath test_path(FILE_PATH_LITERAL("AnyPath"));
   manager->RegisterSwiftShaderPath(test_path);
   EXPECT_EQ(0, manager->GetBlacklistedFeatures());
   EXPECT_TRUE(manager->GpuAccessAllowed());
   EXPECT_FALSE(manager->ShouldUseSoftwareRendering());
 
   manager->BlacklistCard();
   EXPECT_TRUE(manager->GpuAccessAllowed());
   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);
 
   {
     base::RunLoop run_loop;
     run_loop.RunUntilIdle();
   }
   EXPECT_FALSE(observer.gpu_info_updated());
 
   GPUInfo gpu_info;
   manager->UpdateGpuInfo(gpu_info);
   {
     base::RunLoop run_loop;
     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"));
   manager->RegisterSwiftShaderPath(test_path);
   EXPECT_TRUE(manager->ShouldUseSoftwareRendering());
   EXPECT_TRUE(manager->GpuAccessAllowed());
 
   {
     base::RunLoop run_loop;
     run_loop.RunUntilIdle();
   }
 
   TestObserver observer;
   manager->AddObserver(&observer);
   {
     base::RunLoop run_loop;
     run_loop.RunUntilIdle();
   }
   EXPECT_FALSE(observer.gpu_info_updated());
 
   GPUInfo gpu_info;
   manager->UpdateGpuInfo(gpu_info);
   {
     base::RunLoop run_loop;
     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);
 
   {
     base::RunLoop run_loop;
     run_loop.RunUntilIdle();
   }
   EXPECT_FALSE(observer.video_memory_usage_stats_updated());
 
   GPUVideoMemoryUsageStats vram_stats;
   manager->UpdateVideoMemoryUsageStats(vram_stats);
   {
     base::RunLoop run_loop;
     run_loop.RunUntilIdle();
   }
   EXPECT_TRUE(observer.video_memory_usage_stats_updated());
+}
 
-  delete manager;
+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());
+
+  // 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