Refactor GpuDataManagerImpl to make it thread-safe, now and forever.

content/browser/gpu/gpu_data_manager_impl_unittest.cc

Index: content/browser/gpu/gpu_data_manager_impl_unittest.cc
===================================================================
--- content/browser/gpu/gpu_data_manager_impl_unittest.cc	(revision 199087)
+++ content/browser/gpu/gpu_data_manager_impl_unittest.cc	(working copy)
@@ -1,4 +1,4 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Copyright (c) 2013 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.
 
@@ -6,7 +6,7 @@
 #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/browser/gpu/gpu_data_manager_impl_private.h"
 #include "content/public/browser/gpu_data_manager_observer.h"
 #include "content/public/common/gpu_feature_type.h"
 #include "content/public/common/gpu_info.h"
@@ -67,33 +67,14 @@
   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);
-  };
-
   virtual void SetUp() {
   }
 
   virtual void TearDown() {
   }
 
-  base::Time JustBeforeExpiration(GpuDataManagerImpl* manager);
-  base::Time JustAfterExpiration(GpuDataManagerImpl* manager);
+  base::Time JustBeforeExpiration(const GpuDataManagerImplPrivate& manager);
+  base::Time JustAfterExpiration(const GpuDataManagerImplPrivate& manager);
   void TestBlockingDomainFrom3DAPIs(
       GpuDataManagerImpl::DomainGuilt guilt_level);
   void TestUnblockingDomainFrom3DAPIs(
@@ -110,11 +91,10 @@
   // 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.
-  ScopedGpuDataManagerImpl manager;
-  ASSERT_TRUE(manager.get());
-  EXPECT_EQ(0u, manager->GetBlacklistedFeatureCount());
+  GpuDataManagerImplPrivate manager;
+  EXPECT_EQ(0u, manager.GetBlacklistedFeatureCount());
   std::string reason;
-  EXPECT_TRUE(manager->GpuAccessAllowed(&reason));
+  EXPECT_TRUE(manager.GpuAccessAllowed(&reason));
   EXPECT_TRUE(reason.empty());
 
   const std::string blacklist_json = LONG_STRING_CONST(
@@ -145,29 +125,28 @@
   GPUInfo gpu_info;
   gpu_info.gpu.vendor_id = 0x10de;
   gpu_info.gpu.device_id = 0x0640;
-  manager->InitializeForTesting(blacklist_json, gpu_info);
+  manager.InitializeForTesting(blacklist_json, gpu_info);
 
-  EXPECT_TRUE(manager->GpuAccessAllowed(&reason));
+  EXPECT_TRUE(manager.GpuAccessAllowed(&reason));
   EXPECT_TRUE(reason.empty());
-  EXPECT_EQ(1u, manager->GetBlacklistedFeatureCount());
-  EXPECT_TRUE(manager->IsFeatureBlacklisted(GPU_FEATURE_TYPE_WEBGL));
+  EXPECT_EQ(1u, manager.GetBlacklistedFeatureCount());
+  EXPECT_TRUE(manager.IsFeatureBlacklisted(GPU_FEATURE_TYPE_WEBGL));
 
   gpu_info.gl_vendor = "NVIDIA";
   gpu_info.gl_renderer = "NVIDIA GeForce GT 120";
-  manager->UpdateGpuInfo(gpu_info);
-  EXPECT_FALSE(manager->GpuAccessAllowed(&reason));
+  manager.UpdateGpuInfo(gpu_info);
+  EXPECT_FALSE(manager.GpuAccessAllowed(&reason));
   EXPECT_FALSE(reason.empty());
-  EXPECT_EQ(2u, manager->GetBlacklistedFeatureCount());
-  EXPECT_TRUE(manager->IsFeatureBlacklisted(GPU_FEATURE_TYPE_WEBGL));
-  EXPECT_TRUE(manager->IsFeatureBlacklisted(
+  EXPECT_EQ(2u, manager.GetBlacklistedFeatureCount());
+  EXPECT_TRUE(manager.IsFeatureBlacklisted(GPU_FEATURE_TYPE_WEBGL));
+  EXPECT_TRUE(manager.IsFeatureBlacklisted(
       GPU_FEATURE_TYPE_ACCELERATED_2D_CANVAS));
 }
 
 TEST_F(GpuDataManagerImplTest, GpuSideExceptions) {
-  ScopedGpuDataManagerImpl manager;
-  ASSERT_TRUE(manager.get());
-  EXPECT_EQ(0u, manager->GetBlacklistedFeatureCount());
-  EXPECT_TRUE(manager->GpuAccessAllowed(NULL));
+  GpuDataManagerImplPrivate manager;
+  EXPECT_EQ(0u, manager.GetBlacklistedFeatureCount());
+  EXPECT_TRUE(manager.GpuAccessAllowed(NULL));
 
   const std::string blacklist_json = LONG_STRING_CONST(
       {
@@ -194,84 +173,80 @@
   GPUInfo gpu_info;
   gpu_info.gpu.vendor_id = 0x10de;
   gpu_info.gpu.device_id = 0x0640;
-  manager->InitializeForTesting(blacklist_json, gpu_info);
+  manager.InitializeForTesting(blacklist_json, gpu_info);
 
-  EXPECT_TRUE(manager->GpuAccessAllowed(NULL));
-  EXPECT_EQ(0u, manager->GetBlacklistedFeatureCount());
+  EXPECT_TRUE(manager.GpuAccessAllowed(NULL));
+  EXPECT_EQ(0u, manager.GetBlacklistedFeatureCount());
 
   // Now assume 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(NULL));
-  EXPECT_EQ(0u, manager->GetBlacklistedFeatureCount());
+  manager.UpdateGpuInfo(gpu_info);
+  EXPECT_TRUE(manager.GpuAccessAllowed(NULL));
+  EXPECT_EQ(0u, manager.GetBlacklistedFeatureCount());
 }
 
 TEST_F(GpuDataManagerImplTest, DisableHardwareAcceleration) {
-  ScopedGpuDataManagerImpl manager;
-  ASSERT_TRUE(manager.get());
-  EXPECT_EQ(0u, manager->GetBlacklistedFeatureCount());
+  GpuDataManagerImplPrivate manager;
+  EXPECT_EQ(0u, manager.GetBlacklistedFeatureCount());
   std::string reason;
-  EXPECT_TRUE(manager->GpuAccessAllowed(&reason));
+  EXPECT_TRUE(manager.GpuAccessAllowed(&reason));
   EXPECT_TRUE(reason.empty());
 
-  manager->DisableHardwareAcceleration();
-  EXPECT_FALSE(manager->GpuAccessAllowed(&reason));
+  manager.DisableHardwareAcceleration();
+  EXPECT_FALSE(manager.GpuAccessAllowed(&reason));
   EXPECT_FALSE(reason.empty());
   EXPECT_EQ(static_cast<size_t>(NUMBER_OF_GPU_FEATURE_TYPES),
-            manager->GetBlacklistedFeatureCount());
+            manager.GetBlacklistedFeatureCount());
 }
 
 TEST_F(GpuDataManagerImplTest, SwiftShaderRendering) {
   // Blacklist, then register SwiftShader.
-  ScopedGpuDataManagerImpl manager;
-  ASSERT_TRUE(manager.get());
-  EXPECT_EQ(0u, manager->GetBlacklistedFeatureCount());
-  EXPECT_TRUE(manager->GpuAccessAllowed(NULL));
-  EXPECT_FALSE(manager->ShouldUseSwiftShader());
+  GpuDataManagerImplPrivate manager;
+  EXPECT_EQ(0u, manager.GetBlacklistedFeatureCount());
+  EXPECT_TRUE(manager.GpuAccessAllowed(NULL));
+  EXPECT_FALSE(manager.ShouldUseSwiftShader());
 
-  manager->DisableHardwareAcceleration();
-  EXPECT_FALSE(manager->GpuAccessAllowed(NULL));
-  EXPECT_FALSE(manager->ShouldUseSwiftShader());
+  manager.DisableHardwareAcceleration();
+  EXPECT_FALSE(manager.GpuAccessAllowed(NULL));
+  EXPECT_FALSE(manager.ShouldUseSwiftShader());
 
   // If SwiftShader is enabled, even if we blacklist GPU,
   // GPU process is still allowed.
   const base::FilePath test_path(FILE_PATH_LITERAL("AnyPath"));
-  manager->RegisterSwiftShaderPath(test_path);
-  EXPECT_TRUE(manager->ShouldUseSwiftShader());
-  EXPECT_TRUE(manager->GpuAccessAllowed(NULL));
-  EXPECT_EQ(1u, manager->GetBlacklistedFeatureCount());
+  manager.RegisterSwiftShaderPath(test_path);
+  EXPECT_TRUE(manager.ShouldUseSwiftShader());
+  EXPECT_TRUE(manager.GpuAccessAllowed(NULL));
+  EXPECT_EQ(1u, manager.GetBlacklistedFeatureCount());
   EXPECT_TRUE(
-      manager->IsFeatureBlacklisted(GPU_FEATURE_TYPE_ACCELERATED_2D_CANVAS));
+      manager.IsFeatureBlacklisted(GPU_FEATURE_TYPE_ACCELERATED_2D_CANVAS));
 }
 
 TEST_F(GpuDataManagerImplTest, SwiftShaderRendering2) {
   // Register SwiftShader, then blacklist.
-  ScopedGpuDataManagerImpl manager;
-  ASSERT_TRUE(manager.get());
-  EXPECT_EQ(0u, manager->GetBlacklistedFeatureCount());
-  EXPECT_TRUE(manager->GpuAccessAllowed(NULL));
-  EXPECT_FALSE(manager->ShouldUseSwiftShader());
+  GpuDataManagerImplPrivate manager;
+  EXPECT_EQ(0u, manager.GetBlacklistedFeatureCount());
+  EXPECT_TRUE(manager.GpuAccessAllowed(NULL));
+  EXPECT_FALSE(manager.ShouldUseSwiftShader());
 
   const base::FilePath test_path(FILE_PATH_LITERAL("AnyPath"));
-  manager->RegisterSwiftShaderPath(test_path);
-  EXPECT_EQ(0u, manager->GetBlacklistedFeatureCount());
-  EXPECT_TRUE(manager->GpuAccessAllowed(NULL));
-  EXPECT_FALSE(manager->ShouldUseSwiftShader());
+  manager.RegisterSwiftShaderPath(test_path);
+  EXPECT_EQ(0u, manager.GetBlacklistedFeatureCount());
+  EXPECT_TRUE(manager.GpuAccessAllowed(NULL));
+  EXPECT_FALSE(manager.ShouldUseSwiftShader());
 
-  manager->DisableHardwareAcceleration();
-  EXPECT_TRUE(manager->GpuAccessAllowed(NULL));
-  EXPECT_TRUE(manager->ShouldUseSwiftShader());
-  EXPECT_EQ(1u, manager->GetBlacklistedFeatureCount());
+  manager.DisableHardwareAcceleration();
+  EXPECT_TRUE(manager.GpuAccessAllowed(NULL));
+  EXPECT_TRUE(manager.ShouldUseSwiftShader());
+  EXPECT_EQ(1u, manager.GetBlacklistedFeatureCount());
   EXPECT_TRUE(
-      manager->IsFeatureBlacklisted(GPU_FEATURE_TYPE_ACCELERATED_2D_CANVAS));
+      manager.IsFeatureBlacklisted(GPU_FEATURE_TYPE_ACCELERATED_2D_CANVAS));
 }
 
 TEST_F(GpuDataManagerImplTest, GpuInfoUpdate) {
-  ScopedGpuDataManagerImpl manager;
-  ASSERT_TRUE(manager.get());
+  GpuDataManagerImplPrivate manager;
 
   TestObserver observer;
-  manager->AddObserver(&observer);
+  manager.AddObserver(&observer);
 
   {
     base::RunLoop run_loop;
@@ -280,7 +255,7 @@
   EXPECT_FALSE(observer.gpu_info_updated());
 
   GPUInfo gpu_info;
-  manager->UpdateGpuInfo(gpu_info);
+  manager.UpdateGpuInfo(gpu_info);
   {
     base::RunLoop run_loop;
     run_loop.RunUntilIdle();
@@ -289,14 +264,13 @@
 }
 
 TEST_F(GpuDataManagerImplTest, NoGpuInfoUpdateWithSwiftShader) {
-  ScopedGpuDataManagerImpl manager;
-  ASSERT_TRUE(manager.get());
+  GpuDataManagerImplPrivate manager;
 
-  manager->DisableHardwareAcceleration();
+  manager.DisableHardwareAcceleration();
   const base::FilePath test_path(FILE_PATH_LITERAL("AnyPath"));
-  manager->RegisterSwiftShaderPath(test_path);
-  EXPECT_TRUE(manager->ShouldUseSwiftShader());
-  EXPECT_TRUE(manager->GpuAccessAllowed(NULL));
+  manager.RegisterSwiftShaderPath(test_path);
+  EXPECT_TRUE(manager.ShouldUseSwiftShader());
+  EXPECT_TRUE(manager.GpuAccessAllowed(NULL));
 
   {
     base::RunLoop run_loop;
@@ -304,7 +278,7 @@
   }
 
   TestObserver observer;
-  manager->AddObserver(&observer);
+  manager.AddObserver(&observer);
   {
     base::RunLoop run_loop;
     run_loop.RunUntilIdle();
@@ -312,7 +286,7 @@
   EXPECT_FALSE(observer.gpu_info_updated());
 
   GPUInfo gpu_info;
-  manager->UpdateGpuInfo(gpu_info);
+  manager.UpdateGpuInfo(gpu_info);
   {
     base::RunLoop run_loop;
     run_loop.RunUntilIdle();
@@ -321,11 +295,10 @@
 }
 
 TEST_F(GpuDataManagerImplTest, GPUVideoMemoryUsageStatsUpdate) {
-  ScopedGpuDataManagerImpl manager;
-  ASSERT_TRUE(manager.get());
+  GpuDataManagerImplPrivate manager;
 
   TestObserver observer;
-  manager->AddObserver(&observer);
+  manager.AddObserver(&observer);
 
   {
     base::RunLoop run_loop;
@@ -334,7 +307,7 @@
   EXPECT_FALSE(observer.video_memory_usage_stats_updated());
 
   GPUVideoMemoryUsageStats vram_stats;
-  manager->UpdateVideoMemoryUsageStats(vram_stats);
+  manager.UpdateVideoMemoryUsageStats(vram_stats);
   {
     base::RunLoop run_loop;
     run_loop.RunUntilIdle();
@@ -343,60 +316,58 @@
 }
 
 base::Time GpuDataManagerImplTest::JustBeforeExpiration(
-    GpuDataManagerImpl* manager) {
+    const GpuDataManagerImplPrivate& manager) {
   return GetTimeForTesting() + base::TimeDelta::FromMilliseconds(
-      manager->GetBlockAllDomainsDurationInMs()) -
+      manager.GetBlockAllDomainsDurationInMs()) -
       base::TimeDelta::FromMilliseconds(3);
 }
 
 base::Time GpuDataManagerImplTest::JustAfterExpiration(
-    GpuDataManagerImpl* manager) {
+    const GpuDataManagerImplPrivate& manager) {
   return GetTimeForTesting() + base::TimeDelta::FromMilliseconds(
-      manager->GetBlockAllDomainsDurationInMs()) +
+      manager.GetBlockAllDomainsDurationInMs()) +
       base::TimeDelta::FromMilliseconds(3);
 }
 
 void GpuDataManagerImplTest::TestBlockingDomainFrom3DAPIs(
     GpuDataManagerImpl::DomainGuilt guilt_level) {
-  ScopedGpuDataManagerImpl manager;
-  ASSERT_TRUE(manager.get());
+  GpuDataManagerImplPrivate manager;
 
-  manager->BlockDomainFrom3DAPIsAtTime(GetDomain1ForTesting(),
-                                       guilt_level,
-                                       GetTimeForTesting());
+  manager.BlockDomainFrom3DAPIsAtTime(GetDomain1ForTesting(),
+                                      guilt_level,
+                                      GetTimeForTesting());
 
   // This domain should be blocked no matter what.
   EXPECT_EQ(GpuDataManagerImpl::DOMAIN_BLOCK_STATUS_BLOCKED,
-            manager->Are3DAPIsBlockedAtTime(GetDomain1ForTesting(),
-                                            GetTimeForTesting()));
+            manager.Are3DAPIsBlockedAtTime(GetDomain1ForTesting(),
+                                           GetTimeForTesting()));
   EXPECT_EQ(GpuDataManagerImpl::DOMAIN_BLOCK_STATUS_BLOCKED,
-            manager->Are3DAPIsBlockedAtTime(GetDomain1ForTesting(),
-                                            JustBeforeExpiration(manager)));
+            manager.Are3DAPIsBlockedAtTime(
+                GetDomain1ForTesting(), JustBeforeExpiration(manager)));
   EXPECT_EQ(GpuDataManagerImpl::DOMAIN_BLOCK_STATUS_BLOCKED,
-            manager->Are3DAPIsBlockedAtTime(GetDomain1ForTesting(),
-                                            JustAfterExpiration(manager)));
+            manager.Are3DAPIsBlockedAtTime(
+                GetDomain1ForTesting(), JustAfterExpiration(manager)));
 }
 
 void GpuDataManagerImplTest::TestUnblockingDomainFrom3DAPIs(
     GpuDataManagerImpl::DomainGuilt guilt_level) {
-  ScopedGpuDataManagerImpl manager;
-  ASSERT_TRUE(manager.get());
+  GpuDataManagerImplPrivate manager;
 
-  manager->BlockDomainFrom3DAPIsAtTime(GetDomain1ForTesting(),
-                                       guilt_level,
-                                       GetTimeForTesting());
+  manager.BlockDomainFrom3DAPIsAtTime(GetDomain1ForTesting(),
+                                      guilt_level,
+                                      GetTimeForTesting());
 
   // Unblocking the domain should work.
-  manager->UnblockDomainFrom3DAPIs(GetDomain1ForTesting());
+  manager.UnblockDomainFrom3DAPIs(GetDomain1ForTesting());
   EXPECT_EQ(GpuDataManagerImpl::DOMAIN_BLOCK_STATUS_NOT_BLOCKED,
-            manager->Are3DAPIsBlockedAtTime(GetDomain1ForTesting(),
-                                            GetTimeForTesting()));
+            manager.Are3DAPIsBlockedAtTime(GetDomain1ForTesting(),
+                                           GetTimeForTesting()));
   EXPECT_EQ(GpuDataManagerImpl::DOMAIN_BLOCK_STATUS_NOT_BLOCKED,
-            manager->Are3DAPIsBlockedAtTime(GetDomain1ForTesting(),
-                                            JustBeforeExpiration(manager)));
+            manager.Are3DAPIsBlockedAtTime(
+                GetDomain1ForTesting(), JustBeforeExpiration(manager)));
   EXPECT_EQ(GpuDataManagerImpl::DOMAIN_BLOCK_STATUS_NOT_BLOCKED,
-            manager->Are3DAPIsBlockedAtTime(GetDomain1ForTesting(),
-                                            JustAfterExpiration(manager)));
+            manager.Are3DAPIsBlockedAtTime(
+                GetDomain1ForTesting(), JustAfterExpiration(manager)));
 }
 
 TEST_F(GpuDataManagerImplTest, BlockGuiltyDomainFrom3DAPIs) {
@@ -408,20 +379,19 @@
 }
 
 TEST_F(GpuDataManagerImplTest, BlockAllDomainsFrom3DAPIs) {
-  ScopedGpuDataManagerImpl manager;
-  ASSERT_TRUE(manager.get());
+  GpuDataManagerImplPrivate manager;
 
-  manager->BlockDomainFrom3DAPIsAtTime(GetDomain1ForTesting(),
-                                       GpuDataManagerImpl::DOMAIN_GUILT_UNKNOWN,
-                                       GetTimeForTesting());
+  manager.BlockDomainFrom3DAPIsAtTime(GetDomain1ForTesting(),
+                                      GpuDataManagerImpl::DOMAIN_GUILT_UNKNOWN,
+                                      GetTimeForTesting());
 
   // Blocking of other domains should expire.
   EXPECT_EQ(GpuDataManagerImpl::DOMAIN_BLOCK_STATUS_ALL_DOMAINS_BLOCKED,
-            manager->Are3DAPIsBlockedAtTime(GetDomain2ForTesting(),
-                                            JustBeforeExpiration(manager)));
+            manager.Are3DAPIsBlockedAtTime(
+                GetDomain2ForTesting(), JustBeforeExpiration(manager)));
   EXPECT_EQ(GpuDataManagerImpl::DOMAIN_BLOCK_STATUS_NOT_BLOCKED,
-            manager->Are3DAPIsBlockedAtTime(GetDomain2ForTesting(),
-                                            JustAfterExpiration(manager)));
+            manager.Are3DAPIsBlockedAtTime(
+                GetDomain2ForTesting(), JustAfterExpiration(manager)));
 }
 
 TEST_F(GpuDataManagerImplTest, UnblockGuiltyDomainFrom3DAPIs) {
@@ -433,40 +403,38 @@
 }
 
 TEST_F(GpuDataManagerImplTest, UnblockOtherDomainFrom3DAPIs) {
-  ScopedGpuDataManagerImpl manager;
-  ASSERT_TRUE(manager.get());
+  GpuDataManagerImplPrivate manager;
 
-  manager->BlockDomainFrom3DAPIsAtTime(GetDomain1ForTesting(),
-                                       GpuDataManagerImpl::DOMAIN_GUILT_UNKNOWN,
-                                       GetTimeForTesting());
+  manager.BlockDomainFrom3DAPIsAtTime(GetDomain1ForTesting(),
+                                      GpuDataManagerImpl::DOMAIN_GUILT_UNKNOWN,
+                                      GetTimeForTesting());
 
-  manager->UnblockDomainFrom3DAPIs(GetDomain2ForTesting());
+  manager.UnblockDomainFrom3DAPIs(GetDomain2ForTesting());
 
   EXPECT_EQ(GpuDataManagerImpl::DOMAIN_BLOCK_STATUS_NOT_BLOCKED,
-            manager->Are3DAPIsBlockedAtTime(GetDomain2ForTesting(),
-                                            JustBeforeExpiration(manager)));
+            manager.Are3DAPIsBlockedAtTime(
+                GetDomain2ForTesting(), JustBeforeExpiration(manager)));
 
   // The original domain should still be blocked.
   EXPECT_EQ(GpuDataManagerImpl::DOMAIN_BLOCK_STATUS_BLOCKED,
-            manager->Are3DAPIsBlockedAtTime(GetDomain1ForTesting(),
-                                            JustBeforeExpiration(manager)));
+            manager.Are3DAPIsBlockedAtTime(
+                GetDomain1ForTesting(), JustBeforeExpiration(manager)));
 }
 
 TEST_F(GpuDataManagerImplTest, UnblockThisDomainFrom3DAPIs) {
-  ScopedGpuDataManagerImpl manager;
-  ASSERT_TRUE(manager.get());
+  GpuDataManagerImplPrivate manager;
 
-  manager->BlockDomainFrom3DAPIsAtTime(GetDomain1ForTesting(),
-                                       GpuDataManagerImpl::DOMAIN_GUILT_UNKNOWN,
-                                       GetTimeForTesting());
+  manager.BlockDomainFrom3DAPIsAtTime(GetDomain1ForTesting(),
+                                      GpuDataManagerImpl::DOMAIN_GUILT_UNKNOWN,
+                                      GetTimeForTesting());
 
-  manager->UnblockDomainFrom3DAPIs(GetDomain1ForTesting());
+  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,
-            manager->Are3DAPIsBlockedAtTime(GetDomain2ForTesting(),
-                                            JustBeforeExpiration(manager)));
+            manager.Are3DAPIsBlockedAtTime(
+                GetDomain2ForTesting(), JustBeforeExpiration(manager)));
 }
 
 #if defined(OS_LINUX)
@@ -475,10 +443,9 @@
   const char* kGLRendererMesa = "Mesa DRI Intel(R) G41";
   const char* kGLVersionMesa801 = "2.1 Mesa 8.0.1-DEVEL";
 
-  ScopedGpuDataManagerImpl manager;
-  ASSERT_TRUE(manager.get());
-  EXPECT_EQ(0u, manager->GetBlacklistedFeatureCount());
-  EXPECT_TRUE(manager->GpuAccessAllowed(NULL));
+  GpuDataManagerImplPrivate manager;
+  EXPECT_EQ(0u, manager.GetBlacklistedFeatureCount());
+  EXPECT_TRUE(manager.GpuAccessAllowed(NULL));
 
   const std::string blacklist_json = LONG_STRING_CONST(
       {
@@ -507,20 +474,20 @@
   GPUInfo gpu_info;
   gpu_info.gpu.vendor_id = 0x8086;
   gpu_info.gpu.device_id = 0x0042;
-  manager->InitializeForTesting(blacklist_json, gpu_info);
+  manager.InitializeForTesting(blacklist_json, gpu_info);
 
   // Not enough GPUInfo.
-  EXPECT_TRUE(manager->GpuAccessAllowed(NULL));
-  EXPECT_EQ(0u, manager->GetBlacklistedFeatureCount());
+  EXPECT_TRUE(manager.GpuAccessAllowed(NULL));
+  EXPECT_EQ(0u, manager.GetBlacklistedFeatureCount());
 
   // Now assume browser gets GL strings from local state.
   // The entry applies, blacklist more features than from the preliminary step.
   // However, GPU process is not blocked because this is all browser side and
   // happens before renderer launching.
-  manager->SetGLStrings(kGLVendorMesa, kGLRendererMesa, kGLVersionMesa801);
-  EXPECT_TRUE(manager->GpuAccessAllowed(NULL));
-  EXPECT_EQ(1u, manager->GetBlacklistedFeatureCount());
-  EXPECT_TRUE(manager->IsFeatureBlacklisted(GPU_FEATURE_TYPE_WEBGL));
+  manager.SetGLStrings(kGLVendorMesa, kGLRendererMesa, kGLVersionMesa801);
+  EXPECT_TRUE(manager.GpuAccessAllowed(NULL));
+  EXPECT_EQ(1u, manager.GetBlacklistedFeatureCount());
+  EXPECT_TRUE(manager.IsFeatureBlacklisted(GPU_FEATURE_TYPE_WEBGL));
 }
 
 TEST_F(GpuDataManagerImplTest, SetGLStringsNoEffects) {
@@ -529,10 +496,9 @@
   const char* kGLVersionMesa801 = "2.1 Mesa 8.0.1-DEVEL";
   const char* kGLVersionMesa802 = "2.1 Mesa 8.0.2-DEVEL";
 
-  ScopedGpuDataManagerImpl manager;
-  ASSERT_TRUE(manager.get());
-  EXPECT_EQ(0u, manager->GetBlacklistedFeatureCount());
-  EXPECT_TRUE(manager->GpuAccessAllowed(NULL));
+  GpuDataManagerImplPrivate manager;
+  EXPECT_EQ(0u, manager.GetBlacklistedFeatureCount());
+  EXPECT_TRUE(manager.GpuAccessAllowed(NULL));
 
   const std::string blacklist_json = LONG_STRING_CONST(
       {
@@ -566,30 +532,29 @@
   gpu_info.gl_version = kGLVersionMesa801;
   gpu_info.driver_vendor = "Mesa";
   gpu_info.driver_version = "8.0.1";
-  manager->InitializeForTesting(blacklist_json, gpu_info);
+  manager.InitializeForTesting(blacklist_json, gpu_info);
 
   // Full GPUInfo, the entry applies.
-  EXPECT_TRUE(manager->GpuAccessAllowed(NULL));
-  EXPECT_EQ(1u, manager->GetBlacklistedFeatureCount());
-  EXPECT_TRUE(manager->IsFeatureBlacklisted(GPU_FEATURE_TYPE_WEBGL));
+  EXPECT_TRUE(manager.GpuAccessAllowed(NULL));
+  EXPECT_EQ(1u, manager.GetBlacklistedFeatureCount());
+  EXPECT_TRUE(manager.IsFeatureBlacklisted(GPU_FEATURE_TYPE_WEBGL));
 
   // Now assume browser gets GL strings from local state.
   // SetGLStrings() has no effects because GPUInfo already got these strings.
   // (Otherwise the entry should not apply.)
-  manager->SetGLStrings(kGLVendorMesa, kGLRendererMesa, kGLVersionMesa802);
-  EXPECT_TRUE(manager->GpuAccessAllowed(NULL));
-  EXPECT_EQ(1u, manager->GetBlacklistedFeatureCount());
-  EXPECT_TRUE(manager->IsFeatureBlacklisted(GPU_FEATURE_TYPE_WEBGL));
+  manager.SetGLStrings(kGLVendorMesa, kGLRendererMesa, kGLVersionMesa802);
+  EXPECT_TRUE(manager.GpuAccessAllowed(NULL));
+  EXPECT_EQ(1u, manager.GetBlacklistedFeatureCount());
+  EXPECT_TRUE(manager.IsFeatureBlacklisted(GPU_FEATURE_TYPE_WEBGL));
 }
 #endif  // OS_LINUX
 
 TEST_F(GpuDataManagerImplTest, GpuDriverBugListSingle) {
-  ScopedGpuDataManagerImpl manager;
-  ASSERT_TRUE(manager.get());
-  manager->gpu_driver_bugs_.insert(5);
+  GpuDataManagerImplPrivate manager;
+  manager.gpu_driver_bugs_.insert(5);
 
   CommandLine command_line(0, NULL);
-  manager->AppendGpuCommandLine(&command_line);
+  manager.AppendGpuCommandLine(&command_line);
 
   EXPECT_TRUE(command_line.HasSwitch(switches::kGpuDriverBugWorkarounds));
   std::string args = command_line.GetSwitchValueASCII(
@@ -598,13 +563,12 @@
 }
 
 TEST_F(GpuDataManagerImplTest, GpuDriverBugListMultiple) {
-  ScopedGpuDataManagerImpl manager;
-  ASSERT_TRUE(manager.get());
-  manager->gpu_driver_bugs_.insert(5);
-  manager->gpu_driver_bugs_.insert(7);
+  GpuDataManagerImplPrivate manager;
+  manager.gpu_driver_bugs_.insert(5);
+  manager.gpu_driver_bugs_.insert(7);
 
   CommandLine command_line(0, NULL);
-  manager->AppendGpuCommandLine(&command_line);
+  manager.AppendGpuCommandLine(&command_line);
 
   EXPECT_TRUE(command_line.HasSwitch(switches::kGpuDriverBugWorkarounds));
   std::string args = command_line.GetSwitchValueASCII(
@@ -613,11 +577,10 @@
 }
 
 TEST_F(GpuDataManagerImplTest, BlacklistAllFeatures) {
-  ScopedGpuDataManagerImpl manager;
-  ASSERT_TRUE(manager.get());
-  EXPECT_EQ(0u, manager->GetBlacklistedFeatureCount());
+  GpuDataManagerImplPrivate manager;
+  EXPECT_EQ(0u, manager.GetBlacklistedFeatureCount());
   std::string reason;
-  EXPECT_TRUE(manager->GpuAccessAllowed(&reason));
+  EXPECT_TRUE(manager.GpuAccessAllowed(&reason));
   EXPECT_TRUE(reason.empty());
 
   const std::string blacklist_json = LONG_STRING_CONST(
@@ -638,17 +601,17 @@
   GPUInfo gpu_info;
   gpu_info.gpu.vendor_id = 0x10de;
   gpu_info.gpu.device_id = 0x0640;
-  manager->InitializeForTesting(blacklist_json, gpu_info);
+  manager.InitializeForTesting(blacklist_json, gpu_info);
 
   EXPECT_EQ(static_cast<size_t>(NUMBER_OF_GPU_FEATURE_TYPES),
-            manager->GetBlacklistedFeatureCount());
+            manager.GetBlacklistedFeatureCount());
   // TODO(zmo): remove the Linux specific behavior once we fix
   // crbug.com/238466.
 #if defined(OS_LINUX)
-  EXPECT_TRUE(manager->GpuAccessAllowed(&reason));
+  EXPECT_TRUE(manager.GpuAccessAllowed(&reason));
   EXPECT_TRUE(reason.empty());
 #else
-  EXPECT_FALSE(manager->GpuAccessAllowed(&reason));
+  EXPECT_FALSE(manager.GpuAccessAllowed(&reason));
   EXPECT_FALSE(reason.empty());
 #endif
 }