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/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:
   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
@@ skipping 225 matching lines @@
   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) {
+  GpuDataManagerImpl* manager = new GpuDataManagerImpl();

[Zhenyao Mo, 2012/11/14 16:35:58]

You need to manually delete this manager to avoid mem leaking redness

[Ken Russell (switch to Gerrit), 2012/11/14 19:09:14]

I see. I don't think this is maintainable so I've added a
ScopedGpuDataManagerImpl helper class to GpuDataManagerImplTest (needed because
GpuDataManagerImpl's destructor is private and scoped_ptr doesn't work with it)
and changed all the tests in this file to use it.

+  ASSERT_TRUE(manager);
+
+  manager->BlockDomainFrom3DAPIsAtTime(GetDomain1ForTesting(),
+                                       guilt_level,
+                                       GetTimeForTesting());
+
+  // This domain should be blocked no matter what.
+  EXPECT_EQ(GpuDataManager::kDomainBlocked, manager->Are3DAPIsBlockedAtTime(
+      GetDomain1ForTesting(),
+      GetTimeForTesting()));
+  EXPECT_EQ(GpuDataManager::kDomainBlocked, manager->Are3DAPIsBlockedAtTime(
+      GetDomain1ForTesting(),
+      JustBeforeExpiration(manager)));
+  EXPECT_EQ(GpuDataManager::kDomainBlocked, manager->Are3DAPIsBlockedAtTime(
+      GetDomain1ForTesting(),
+      JustAfterExpiration(manager)));
+}
+
+void GpuDataManagerImplTest::TestUnblockingDomainFrom3DAPIs(
+    GpuDataManager::DomainGuilt guilt_level) {
+  GpuDataManagerImpl* manager = new GpuDataManagerImpl();

[Zhenyao Mo, 2012/11/14 16:35:58]

delete manager in the end

+  ASSERT_TRUE(manager);
+
+  manager->BlockDomainFrom3DAPIsAtTime(GetDomain1ForTesting(),
+                                       guilt_level,
+                                       GetTimeForTesting());
+
+  // Unblocking the domain should work.
+  manager->UnblockDomainFrom3DAPIs(GetDomain1ForTesting());
+  EXPECT_EQ(GpuDataManager::kNotBlocked, manager->Are3DAPIsBlockedAtTime(
+      GetDomain1ForTesting(),
+      GetTimeForTesting()));
+  EXPECT_EQ(GpuDataManager::kNotBlocked, manager->Are3DAPIsBlockedAtTime(
+      GetDomain1ForTesting(),
+      JustBeforeExpiration(manager)));
+  EXPECT_EQ(GpuDataManager::kNotBlocked, manager->Are3DAPIsBlockedAtTime(
+      GetDomain1ForTesting(),
+      JustAfterExpiration(manager)));
+}
+
+TEST_F(GpuDataManagerImplTest, BlockGuiltyDomainFrom3DAPIs) {
+  TestBlockingDomainFrom3DAPIs(GpuDataManager::kKnownGuilty);
+}
+
+TEST_F(GpuDataManagerImplTest, BlockDomainOfUnknownGuiltFrom3DAPIs) {
+  TestBlockingDomainFrom3DAPIs(GpuDataManager::kUnknownGuilt);
+}
+
+TEST_F(GpuDataManagerImplTest, BlockAllDomainsFrom3DAPIs) {
+  GpuDataManagerImpl* manager = new GpuDataManagerImpl();

[Zhenyao Mo, 2012/11/14 16:35:58]

delete manager in the end

+  ASSERT_TRUE(manager);
+
+  manager->BlockDomainFrom3DAPIsAtTime(GetDomain1ForTesting(),
+                                       GpuDataManager::kUnknownGuilt,
+                                       GetTimeForTesting());
+
+  // Blocking of other domains should expire.
+  EXPECT_EQ(GpuDataManager::kAllDomainsBlocked, manager->Are3DAPIsBlockedAtTime(
+      GetDomain2ForTesting(),
+      JustBeforeExpiration(manager)));
+  EXPECT_EQ(GpuDataManager::kNotBlocked, manager->Are3DAPIsBlockedAtTime(
+      GetDomain2ForTesting(),
+      JustAfterExpiration(manager)));
+}
+
+TEST_F(GpuDataManagerImplTest, UnblockGuiltyDomainFrom3DAPIs) {
+  TestUnblockingDomainFrom3DAPIs(GpuDataManager::kKnownGuilty);
+}
+
+TEST_F(GpuDataManagerImplTest, UnblockDomainOfUnknownGuiltFrom3DAPIs) {
+  TestUnblockingDomainFrom3DAPIs(GpuDataManager::kUnknownGuilt);
+}
+
+TEST_F(GpuDataManagerImplTest, UnblockOtherDomainFrom3DAPIs) {
+  GpuDataManagerImpl* manager = new GpuDataManagerImpl();

[Zhenyao Mo, 2012/11/14 16:35:58]

delete manager in the end

+  ASSERT_TRUE(manager);
+
+  manager->BlockDomainFrom3DAPIsAtTime(GetDomain1ForTesting(),
+                                       GpuDataManager::kUnknownGuilt,
+                                       GetTimeForTesting());
+
+  manager->UnblockDomainFrom3DAPIs(GetDomain2ForTesting());
+
+  EXPECT_EQ(GpuDataManager::kNotBlocked, manager->Are3DAPIsBlockedAtTime(
+      GetDomain2ForTesting(),
+      JustBeforeExpiration(manager)));
+
+  // The original domain should still be blocked.
+  EXPECT_EQ(GpuDataManager::kDomainBlocked, manager->Are3DAPIsBlockedAtTime(
+      GetDomain1ForTesting(),
+      JustBeforeExpiration(manager)));
+}
+
+TEST_F(GpuDataManagerImplTest, UnblockThisDomainFrom3DAPIs) {
+  GpuDataManagerImpl* manager = new GpuDataManagerImpl();
+  ASSERT_TRUE(manager);
+
+  manager->BlockDomainFrom3DAPIsAtTime(GetDomain1ForTesting(),
+                                       GpuDataManager::kUnknownGuilt,
+                                       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::kNotBlocked, manager->Are3DAPIsBlockedAtTime(
+      GetDomain2ForTesting(),
+      JustBeforeExpiration(manager)));
+}
+
 }  // namespace content