content/browser/gpu/gpu_data_manager_impl_private_unittest.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/command_line.h"
   6 #include "base/message_loop/message_loop.h"
   7 #include "base/run_loop.h"
   8 #include "base/time/time.h"
   9 #include "content/browser/gpu/gpu_data_manager_impl_private.h"
  10 #include "content/public/browser/gpu_data_manager_observer.h"
  11 #include "content/public/common/gpu_feature_type.h"
  12 #include "content/public/common/gpu_info.h"
  13 #include "gpu/command_buffer/service/gpu_switches.h"
  14 #include "testing/gtest/include/gtest/gtest.h"
  15 #include "url/gurl.h"
  16
  17 #define LONG_STRING_CONST(...) #__VA_ARGS__
  18
  19 namespace content {
  20 namespace {
  21
  22 class TestObserver : public GpuDataManagerObserver {
  23  public:
  24   TestObserver()
  25       : gpu_info_updated_(false),
  26         video_memory_usage_stats_updated_(false) {
  27   }
  28   virtual ~TestObserver() { }
  29
  30   bool gpu_info_updated() const { return gpu_info_updated_; }
  31   bool video_memory_usage_stats_updated() const {
  32     return video_memory_usage_stats_updated_;
  33   }
  34
  35   virtual void OnGpuInfoUpdate() OVERRIDE {
  36     gpu_info_updated_ = true;
  37   }
  38
  39   virtual void OnVideoMemoryUsageStatsUpdate(
  40       const GPUVideoMemoryUsageStats& stats) OVERRIDE {
  41     video_memory_usage_stats_updated_ = true;
  42   }
  43
  44  private:
  45   bool gpu_info_updated_;
  46   bool video_memory_usage_stats_updated_;
  47 };
  48
  49 static base::Time GetTimeForTesting() {
  50   return base::Time::FromDoubleT(1000);
  51 }
  52
  53 static GURL GetDomain1ForTesting() {
  54   return GURL("http://foo.com/");
  55 }
  56
  57 static GURL GetDomain2ForTesting() {
  58   return GURL("http://bar.com/");
  59 }
  60
  61 }  // namespace anonymous
  62
  63 class GpuDataManagerImplPrivateTest : public testing::Test {
  64  public:
  65   GpuDataManagerImplPrivateTest() { }
  66
  67   virtual ~GpuDataManagerImplPrivateTest() { }
  68
  69  protected:
  70   // scoped_ptr doesn't work with GpuDataManagerImpl because its
  71   // destructor is private. GpuDataManagerImplPrivateTest is however a friend
  72   // so we can make a little helper class here.
  73   class ScopedGpuDataManagerImpl {
  74    public:
  75     ScopedGpuDataManagerImpl() : impl_(new GpuDataManagerImpl()) {
  76       EXPECT_TRUE(impl_);
  77       EXPECT_TRUE(impl_->private_.get());
  78     }
  79     ~ScopedGpuDataManagerImpl() { delete impl_; }
  80
  81     GpuDataManagerImpl* get() const { return impl_; }
  82
  83     GpuDataManagerImpl* operator->() const { return impl_; }
  84
  85    private:
  86     GpuDataManagerImpl* impl_;
  87     DISALLOW_COPY_AND_ASSIGN(ScopedGpuDataManagerImpl);
  88   };
  89
  90   // We want to test the code path where GpuDataManagerImplPrivate is created
  91   // in the GpuDataManagerImpl constructor.
  92   class ScopedGpuDataManagerImplPrivate {
  93    public:
  94     ScopedGpuDataManagerImplPrivate() : impl_(new GpuDataManagerImpl()) {
  95       EXPECT_TRUE(impl_);
  96       EXPECT_TRUE(impl_->private_.get());
  97     }
  98     ~ScopedGpuDataManagerImplPrivate() { delete impl_; }
  99
 100     GpuDataManagerImplPrivate* get() const {
 101       return impl_->private_.get();
 102     }
 103
 104     GpuDataManagerImplPrivate* operator->() const {
 105       return impl_->private_.get();
 106     }
 107
 108    private:
 109     GpuDataManagerImpl* impl_;
 110     DISALLOW_COPY_AND_ASSIGN(ScopedGpuDataManagerImplPrivate);
 111   };
 112
 113   virtual void SetUp() {
 114   }
 115
 116   virtual void TearDown() {
 117   }
 118
 119   base::Time JustBeforeExpiration(const GpuDataManagerImplPrivate* manager);
 120   base::Time JustAfterExpiration(const GpuDataManagerImplPrivate* manager);
 121   void TestBlockingDomainFrom3DAPIs(
 122       GpuDataManagerImpl::DomainGuilt guilt_level);
 123   void TestUnblockingDomainFrom3DAPIs(
 124       GpuDataManagerImpl::DomainGuilt guilt_level);
 125
 126   base::MessageLoop message_loop_;
 127 };
 128
 129 // We use new method instead of GetInstance() method because we want
 130 // each test to be independent of each other.
 131
 132 TEST_F(GpuDataManagerImplPrivateTest, GpuSideBlacklisting) {
 133   // If a feature is allowed in preliminary step (browser side), but
 134   // disabled when GPU process launches and collects full GPU info,
 135   // it's too late to let renderer know, so we basically block all GPU
 136   // access, to be on the safe side.
 137   ScopedGpuDataManagerImplPrivate manager;
 138   EXPECT_EQ(0u, manager->GetBlacklistedFeatureCount());
 139   std::string reason;
 140   EXPECT_TRUE(manager->GpuAccessAllowed(&reason));
 141   EXPECT_TRUE(reason.empty());
 142
 143   const std::string blacklist_json = LONG_STRING_CONST(
 144       {
 145         "name": "gpu blacklist",
 146         "version": "0.1",
 147         "entries": [
 148           {
 149             "id": 1,
 150             "features": [
 151               "webgl"
 152             ]
 153           },
 154           {
 155             "id": 2,
 156             "gl_renderer": {
 157               "op": "contains",
 158               "value": "GeForce"
 159             },
 160             "features": [
 161               "accelerated_2d_canvas"
 162             ]
 163           }
 164         ]
 165       }
 166   );
 167
 168   GPUInfo gpu_info;
 169   gpu_info.gpu.vendor_id = 0x10de;
 170   gpu_info.gpu.device_id = 0x0640;
 171   manager->InitializeForTesting(blacklist_json, gpu_info);
 172
 173   EXPECT_TRUE(manager->GpuAccessAllowed(&reason));
 174   EXPECT_TRUE(reason.empty());
 175   EXPECT_EQ(1u, manager->GetBlacklistedFeatureCount());
 176   EXPECT_TRUE(manager->IsFeatureBlacklisted(GPU_FEATURE_TYPE_WEBGL));
 177
 178   gpu_info.gl_vendor = "NVIDIA";
 179   gpu_info.gl_renderer = "NVIDIA GeForce GT 120";
 180   manager->UpdateGpuInfo(gpu_info);
 181   EXPECT_FALSE(manager->GpuAccessAllowed(&reason));
 182   EXPECT_FALSE(reason.empty());
 183   EXPECT_EQ(2u, manager->GetBlacklistedFeatureCount());
 184   EXPECT_TRUE(manager->IsFeatureBlacklisted(GPU_FEATURE_TYPE_WEBGL));
 185   EXPECT_TRUE(manager->IsFeatureBlacklisted(
 186       GPU_FEATURE_TYPE_ACCELERATED_2D_CANVAS));
 187 }
 188
 189 TEST_F(GpuDataManagerImplPrivateTest, GpuSideExceptions) {
 190   ScopedGpuDataManagerImplPrivate manager;
 191   EXPECT_EQ(0u, manager->GetBlacklistedFeatureCount());
 192   EXPECT_TRUE(manager->GpuAccessAllowed(NULL));
 193
 194   const std::string blacklist_json = LONG_STRING_CONST(
 195       {
 196         "name": "gpu blacklist",
 197         "version": "0.1",
 198         "entries": [
 199           {
 200             "id": 1,
 201             "exceptions": [
 202               {
 203                 "gl_renderer": {
 204                   "op": "contains",
 205                   "value": "GeForce"
 206                 }
 207               }
 208             ],
 209             "features": [
 210               "webgl"
 211             ]
 212           }
 213         ]
 214       }
 215   );
 216   GPUInfo gpu_info;
 217   gpu_info.gpu.vendor_id = 0x10de;
 218   gpu_info.gpu.device_id = 0x0640;
 219   manager->InitializeForTesting(blacklist_json, gpu_info);
 220
 221   EXPECT_TRUE(manager->GpuAccessAllowed(NULL));
 222   EXPECT_EQ(0u, manager->GetBlacklistedFeatureCount());
 223
 224   // Now assume gpu process launches and full GPU info is collected.
 225   gpu_info.gl_renderer = "NVIDIA GeForce GT 120";
 226   manager->UpdateGpuInfo(gpu_info);
 227   EXPECT_TRUE(manager->GpuAccessAllowed(NULL));
 228   EXPECT_EQ(0u, manager->GetBlacklistedFeatureCount());
 229 }
 230
 231 TEST_F(GpuDataManagerImplPrivateTest, DisableHardwareAcceleration) {
 232   ScopedGpuDataManagerImplPrivate manager;
 233   EXPECT_EQ(0u, manager->GetBlacklistedFeatureCount());
 234   std::string reason;
 235   EXPECT_TRUE(manager->GpuAccessAllowed(&reason));
 236   EXPECT_TRUE(reason.empty());
 237
 238   manager->DisableHardwareAcceleration();
 239   EXPECT_FALSE(manager->GpuAccessAllowed(&reason));
 240   EXPECT_FALSE(reason.empty());
 241   EXPECT_EQ(static_cast<size_t>(NUMBER_OF_GPU_FEATURE_TYPES),
 242             manager->GetBlacklistedFeatureCount());
 243 }
 244
 245 TEST_F(GpuDataManagerImplPrivateTest, SwiftShaderRendering) {
 246   // Blacklist, then register SwiftShader.
 247   ScopedGpuDataManagerImplPrivate manager;
 248   EXPECT_EQ(0u, manager->GetBlacklistedFeatureCount());
 249   EXPECT_TRUE(manager->GpuAccessAllowed(NULL));
 250   EXPECT_FALSE(manager->ShouldUseSwiftShader());
 251
 252   manager->DisableHardwareAcceleration();
 253   EXPECT_FALSE(manager->GpuAccessAllowed(NULL));
 254   EXPECT_FALSE(manager->ShouldUseSwiftShader());
 255
 256   // If SwiftShader is enabled, even if we blacklist GPU,
 257   // GPU process is still allowed.
 258   const base::FilePath test_path(FILE_PATH_LITERAL("AnyPath"));
 259   manager->RegisterSwiftShaderPath(test_path);
 260   EXPECT_TRUE(manager->ShouldUseSwiftShader());
 261   EXPECT_TRUE(manager->GpuAccessAllowed(NULL));
 262   EXPECT_EQ(1u, manager->GetBlacklistedFeatureCount());
 263   EXPECT_TRUE(
 264       manager->IsFeatureBlacklisted(GPU_FEATURE_TYPE_ACCELERATED_2D_CANVAS));
 265 }
 266
 267 TEST_F(GpuDataManagerImplPrivateTest, SwiftShaderRendering2) {
 268   // Register SwiftShader, then blacklist.
 269   ScopedGpuDataManagerImplPrivate manager;
 270   EXPECT_EQ(0u, manager->GetBlacklistedFeatureCount());
 271   EXPECT_TRUE(manager->GpuAccessAllowed(NULL));
 272   EXPECT_FALSE(manager->ShouldUseSwiftShader());
 273
 274   const base::FilePath test_path(FILE_PATH_LITERAL("AnyPath"));
 275   manager->RegisterSwiftShaderPath(test_path);
 276   EXPECT_EQ(0u, manager->GetBlacklistedFeatureCount());
 277   EXPECT_TRUE(manager->GpuAccessAllowed(NULL));
 278   EXPECT_FALSE(manager->ShouldUseSwiftShader());
 279
 280   manager->DisableHardwareAcceleration();
 281   EXPECT_TRUE(manager->GpuAccessAllowed(NULL));
 282   EXPECT_TRUE(manager->ShouldUseSwiftShader());
 283   EXPECT_EQ(1u, manager->GetBlacklistedFeatureCount());
 284   EXPECT_TRUE(
 285       manager->IsFeatureBlacklisted(GPU_FEATURE_TYPE_ACCELERATED_2D_CANVAS));
 286 }
 287
 288 TEST_F(GpuDataManagerImplPrivateTest, GpuInfoUpdate) {
 289   ScopedGpuDataManagerImpl manager;
 290
 291   TestObserver observer;
 292   manager->AddObserver(&observer);
 293
 294   {
 295     base::RunLoop run_loop;
 296     run_loop.RunUntilIdle();
 297   }
 298   EXPECT_FALSE(observer.gpu_info_updated());
 299
 300   GPUInfo gpu_info;
 301   manager->UpdateGpuInfo(gpu_info);
 302   {
 303     base::RunLoop run_loop;
 304     run_loop.RunUntilIdle();
 305   }
 306   EXPECT_TRUE(observer.gpu_info_updated());
 307 }
 308
 309 TEST_F(GpuDataManagerImplPrivateTest, NoGpuInfoUpdateWithSwiftShader) {
 310   ScopedGpuDataManagerImpl manager;
 311
 312   manager->DisableHardwareAcceleration();
 313   const base::FilePath test_path(FILE_PATH_LITERAL("AnyPath"));
 314   manager->RegisterSwiftShaderPath(test_path);
 315   EXPECT_TRUE(manager->ShouldUseSwiftShader());
 316   EXPECT_TRUE(manager->GpuAccessAllowed(NULL));
 317
 318   {
 319     base::RunLoop run_loop;
 320     run_loop.RunUntilIdle();
 321   }
 322
 323   TestObserver observer;
 324   manager->AddObserver(&observer);
 325   {
 326     base::RunLoop run_loop;
 327     run_loop.RunUntilIdle();
 328   }
 329   EXPECT_FALSE(observer.gpu_info_updated());
 330
 331   GPUInfo gpu_info;
 332   manager->UpdateGpuInfo(gpu_info);
 333   {
 334     base::RunLoop run_loop;
 335     run_loop.RunUntilIdle();
 336   }
 337   EXPECT_FALSE(observer.gpu_info_updated());
 338 }
 339
 340 TEST_F(GpuDataManagerImplPrivateTest, GPUVideoMemoryUsageStatsUpdate) {
 341   ScopedGpuDataManagerImpl manager;
 342
 343   TestObserver observer;
 344   manager->AddObserver(&observer);
 345
 346   {
 347     base::RunLoop run_loop;
 348     run_loop.RunUntilIdle();
 349   }
 350   EXPECT_FALSE(observer.video_memory_usage_stats_updated());
 351
 352   GPUVideoMemoryUsageStats vram_stats;
 353   manager->UpdateVideoMemoryUsageStats(vram_stats);
 354   {
 355     base::RunLoop run_loop;
 356     run_loop.RunUntilIdle();
 357   }
 358   EXPECT_TRUE(observer.video_memory_usage_stats_updated());
 359 }
 360
 361 base::Time GpuDataManagerImplPrivateTest::JustBeforeExpiration(
 362     const GpuDataManagerImplPrivate* manager) {
 363   return GetTimeForTesting() + base::TimeDelta::FromMilliseconds(
 364       manager->GetBlockAllDomainsDurationInMs()) -
 365       base::TimeDelta::FromMilliseconds(3);
 366 }
 367
 368 base::Time GpuDataManagerImplPrivateTest::JustAfterExpiration(
 369     const GpuDataManagerImplPrivate* manager) {
 370   return GetTimeForTesting() + base::TimeDelta::FromMilliseconds(
 371       manager->GetBlockAllDomainsDurationInMs()) +
 372       base::TimeDelta::FromMilliseconds(3);
 373 }
 374
 375 void GpuDataManagerImplPrivateTest::TestBlockingDomainFrom3DAPIs(
 376     GpuDataManagerImpl::DomainGuilt guilt_level) {
 377   ScopedGpuDataManagerImplPrivate manager;
 378
 379   manager->BlockDomainFrom3DAPIsAtTime(GetDomain1ForTesting(),
 380                                       guilt_level,
 381                                       GetTimeForTesting());
 382
 383   // This domain should be blocked no matter what.
 384   EXPECT_EQ(GpuDataManagerImpl::DOMAIN_BLOCK_STATUS_BLOCKED,
 385             manager->Are3DAPIsBlockedAtTime(GetDomain1ForTesting(),
 386                                            GetTimeForTesting()));
 387   EXPECT_EQ(GpuDataManagerImpl::DOMAIN_BLOCK_STATUS_BLOCKED,
 388             manager->Are3DAPIsBlockedAtTime(
 389                 GetDomain1ForTesting(), JustBeforeExpiration(manager.get())));
 390   EXPECT_EQ(GpuDataManagerImpl::DOMAIN_BLOCK_STATUS_BLOCKED,
 391             manager->Are3DAPIsBlockedAtTime(
 392                 GetDomain1ForTesting(), JustAfterExpiration(manager.get())));
 393 }
 394
 395 void GpuDataManagerImplPrivateTest::TestUnblockingDomainFrom3DAPIs(
 396     GpuDataManagerImpl::DomainGuilt guilt_level) {
 397   ScopedGpuDataManagerImplPrivate manager;
 398
 399   manager->BlockDomainFrom3DAPIsAtTime(GetDomain1ForTesting(),
 400                                        guilt_level,
 401                                        GetTimeForTesting());
 402
 403   // Unblocking the domain should work.
 404   manager->UnblockDomainFrom3DAPIs(GetDomain1ForTesting());
 405   EXPECT_EQ(GpuDataManagerImpl::DOMAIN_BLOCK_STATUS_NOT_BLOCKED,
 406             manager->Are3DAPIsBlockedAtTime(GetDomain1ForTesting(),
 407                                             GetTimeForTesting()));
 408   EXPECT_EQ(GpuDataManagerImpl::DOMAIN_BLOCK_STATUS_NOT_BLOCKED,
 409             manager->Are3DAPIsBlockedAtTime(
 410                 GetDomain1ForTesting(), JustBeforeExpiration(manager.get())));
 411   EXPECT_EQ(GpuDataManagerImpl::DOMAIN_BLOCK_STATUS_NOT_BLOCKED,
 412             manager->Are3DAPIsBlockedAtTime(
 413                 GetDomain1ForTesting(), JustAfterExpiration(manager.get())));
 414 }
 415
 416 TEST_F(GpuDataManagerImplPrivateTest, BlockGuiltyDomainFrom3DAPIs) {
 417   TestBlockingDomainFrom3DAPIs(GpuDataManagerImpl::DOMAIN_GUILT_KNOWN);
 418 }
 419
 420 TEST_F(GpuDataManagerImplPrivateTest, BlockDomainOfUnknownGuiltFrom3DAPIs) {
 421   TestBlockingDomainFrom3DAPIs(GpuDataManagerImpl::DOMAIN_GUILT_UNKNOWN);
 422 }
 423
 424 TEST_F(GpuDataManagerImplPrivateTest, BlockAllDomainsFrom3DAPIs) {
 425   ScopedGpuDataManagerImplPrivate manager;
 426
 427   manager->BlockDomainFrom3DAPIsAtTime(GetDomain1ForTesting(),
 428                                        GpuDataManagerImpl::DOMAIN_GUILT_UNKNOWN,
 429                                        GetTimeForTesting());
 430
 431   // Blocking of other domains should expire.
 432   EXPECT_EQ(GpuDataManagerImpl::DOMAIN_BLOCK_STATUS_ALL_DOMAINS_BLOCKED,
 433             manager->Are3DAPIsBlockedAtTime(
 434                 GetDomain2ForTesting(), JustBeforeExpiration(manager.get())));
 435   EXPECT_EQ(GpuDataManagerImpl::DOMAIN_BLOCK_STATUS_NOT_BLOCKED,
 436             manager->Are3DAPIsBlockedAtTime(
 437                 GetDomain2ForTesting(), JustAfterExpiration(manager.get())));
 438 }
 439
 440 TEST_F(GpuDataManagerImplPrivateTest, UnblockGuiltyDomainFrom3DAPIs) {
 441   TestUnblockingDomainFrom3DAPIs(GpuDataManagerImpl::DOMAIN_GUILT_KNOWN);
 442 }
 443
 444 TEST_F(GpuDataManagerImplPrivateTest, UnblockDomainOfUnknownGuiltFrom3DAPIs) {
 445   TestUnblockingDomainFrom3DAPIs(GpuDataManagerImpl::DOMAIN_GUILT_UNKNOWN);
 446 }
 447
 448 TEST_F(GpuDataManagerImplPrivateTest, UnblockOtherDomainFrom3DAPIs) {
 449   ScopedGpuDataManagerImplPrivate manager;
 450
 451   manager->BlockDomainFrom3DAPIsAtTime(GetDomain1ForTesting(),
 452                                        GpuDataManagerImpl::DOMAIN_GUILT_UNKNOWN,
 453                                        GetTimeForTesting());
 454
 455   manager->UnblockDomainFrom3DAPIs(GetDomain2ForTesting());
 456
 457   EXPECT_EQ(GpuDataManagerImpl::DOMAIN_BLOCK_STATUS_NOT_BLOCKED,
 458             manager->Are3DAPIsBlockedAtTime(
 459                 GetDomain2ForTesting(), JustBeforeExpiration(manager.get())));
 460
 461   // The original domain should still be blocked.
 462   EXPECT_EQ(GpuDataManagerImpl::DOMAIN_BLOCK_STATUS_BLOCKED,
 463             manager->Are3DAPIsBlockedAtTime(
 464                 GetDomain1ForTesting(), JustBeforeExpiration(manager.get())));
 465 }
 466
 467 TEST_F(GpuDataManagerImplPrivateTest, UnblockThisDomainFrom3DAPIs) {
 468   ScopedGpuDataManagerImplPrivate manager;
 469
 470   manager->BlockDomainFrom3DAPIsAtTime(GetDomain1ForTesting(),
 471                                        GpuDataManagerImpl::DOMAIN_GUILT_UNKNOWN,
 472                                        GetTimeForTesting());
 473
 474   manager->UnblockDomainFrom3DAPIs(GetDomain1ForTesting());
 475
 476   // This behavior is debatable. Perhaps the GPU reset caused by
 477   // domain 1 should still cause other domains to be blocked.
 478   EXPECT_EQ(GpuDataManagerImpl::DOMAIN_BLOCK_STATUS_NOT_BLOCKED,
 479             manager->Are3DAPIsBlockedAtTime(
 480                 GetDomain2ForTesting(), JustBeforeExpiration(manager.get())));
 481 }
 482
 483 #if defined(OS_LINUX)
 484 TEST_F(GpuDataManagerImplPrivateTest, SetGLStrings) {
 485   const char* kGLVendorMesa = "Tungsten Graphics, Inc";
 486   const char* kGLRendererMesa = "Mesa DRI Intel(R) G41";
 487   const char* kGLVersionMesa801 = "2.1 Mesa 8.0.1-DEVEL";
 488
 489   ScopedGpuDataManagerImplPrivate manager;
 490   EXPECT_EQ(0u, manager->GetBlacklistedFeatureCount());
 491   EXPECT_TRUE(manager->GpuAccessAllowed(NULL));
 492
 493   const std::string blacklist_json = LONG_STRING_CONST(
 494       {
 495         "name": "gpu blacklist",
 496         "version": "0.1",
 497         "entries": [
 498           {
 499             "id": 1,
 500             "vendor_id": "0x8086",
 501             "exceptions": [
 502               {
 503                 "device_id": ["0x0042"],
 504                 "driver_version": {
 505                   "op": ">=",
 506                   "number": "8.0.2"
 507                 }
 508               }
 509             ],
 510             "features": [
 511               "webgl"
 512             ]
 513           }
 514         ]
 515       }
 516   );
 517   GPUInfo gpu_info;
 518   gpu_info.gpu.vendor_id = 0x8086;
 519   gpu_info.gpu.device_id = 0x0042;
 520   manager->InitializeForTesting(blacklist_json, gpu_info);
 521
 522   // Not enough GPUInfo.
 523   EXPECT_TRUE(manager->GpuAccessAllowed(NULL));
 524   EXPECT_EQ(0u, manager->GetBlacklistedFeatureCount());
 525
 526   // Now assume browser gets GL strings from local state.
 527   // The entry applies, blacklist more features than from the preliminary step.
 528   // However, GPU process is not blocked because this is all browser side and
 529   // happens before renderer launching.
 530   manager->SetGLStrings(kGLVendorMesa, kGLRendererMesa, kGLVersionMesa801);
 531   EXPECT_TRUE(manager->GpuAccessAllowed(NULL));
 532   EXPECT_EQ(1u, manager->GetBlacklistedFeatureCount());
 533   EXPECT_TRUE(manager->IsFeatureBlacklisted(GPU_FEATURE_TYPE_WEBGL));
 534 }
 535
 536 TEST_F(GpuDataManagerImplPrivateTest, SetGLStringsNoEffects) {
 537   const char* kGLVendorMesa = "Tungsten Graphics, Inc";
 538   const char* kGLRendererMesa = "Mesa DRI Intel(R) G41";
 539   const char* kGLVersionMesa801 = "2.1 Mesa 8.0.1-DEVEL";
 540   const char* kGLVersionMesa802 = "2.1 Mesa 8.0.2-DEVEL";
 541
 542   ScopedGpuDataManagerImplPrivate manager;
 543   EXPECT_EQ(0u, manager->GetBlacklistedFeatureCount());
 544   EXPECT_TRUE(manager->GpuAccessAllowed(NULL));
 545
 546   const std::string blacklist_json = LONG_STRING_CONST(
 547       {
 548         "name": "gpu blacklist",
 549         "version": "0.1",
 550         "entries": [
 551           {
 552             "id": 1,
 553             "vendor_id": "0x8086",
 554             "exceptions": [
 555               {
 556                 "device_id": ["0x0042"],
 557                 "driver_version": {
 558                   "op": ">=",
 559                   "number": "8.0.2"
 560                 }
 561               }
 562             ],
 563             "features": [
 564               "webgl"
 565             ]
 566           }
 567         ]
 568       }
 569   );
 570   GPUInfo gpu_info;
 571   gpu_info.gpu.vendor_id = 0x8086;
 572   gpu_info.gpu.device_id = 0x0042;
 573   gpu_info.gl_vendor = kGLVendorMesa;
 574   gpu_info.gl_renderer = kGLRendererMesa;
 575   gpu_info.gl_version = kGLVersionMesa801;
 576   gpu_info.driver_vendor = "Mesa";
 577   gpu_info.driver_version = "8.0.1";
 578   manager->InitializeForTesting(blacklist_json, gpu_info);
 579
 580   // Full GPUInfo, the entry applies.
 581   EXPECT_TRUE(manager->GpuAccessAllowed(NULL));
 582   EXPECT_EQ(1u, manager->GetBlacklistedFeatureCount());
 583   EXPECT_TRUE(manager->IsFeatureBlacklisted(GPU_FEATURE_TYPE_WEBGL));
 584
 585   // Now assume browser gets GL strings from local state.
 586   // SetGLStrings() has no effects because GPUInfo already got these strings.
 587   // (Otherwise the entry should not apply.)
 588   manager->SetGLStrings(kGLVendorMesa, kGLRendererMesa, kGLVersionMesa802);
 589   EXPECT_TRUE(manager->GpuAccessAllowed(NULL));
 590   EXPECT_EQ(1u, manager->GetBlacklistedFeatureCount());
 591   EXPECT_TRUE(manager->IsFeatureBlacklisted(GPU_FEATURE_TYPE_WEBGL));
 592 }
 593 #endif  // OS_LINUX
 594
 595 TEST_F(GpuDataManagerImplPrivateTest, GpuDriverBugListSingle) {
 596   ScopedGpuDataManagerImplPrivate manager;
 597   manager->gpu_driver_bugs_.insert(5);
 598
 599   CommandLine command_line(0, NULL);
 600   manager->AppendGpuCommandLine(&command_line);
 601
 602   EXPECT_TRUE(command_line.HasSwitch(switches::kGpuDriverBugWorkarounds));
 603   std::string args = command_line.GetSwitchValueASCII(
 604       switches::kGpuDriverBugWorkarounds);
 605   EXPECT_STREQ("5", args.c_str());
 606 }
 607
 608 TEST_F(GpuDataManagerImplPrivateTest, GpuDriverBugListMultiple) {
 609   ScopedGpuDataManagerImplPrivate manager;
 610   manager->gpu_driver_bugs_.insert(5);
 611   manager->gpu_driver_bugs_.insert(7);
 612
 613   CommandLine command_line(0, NULL);
 614   manager->AppendGpuCommandLine(&command_line);
 615
 616   EXPECT_TRUE(command_line.HasSwitch(switches::kGpuDriverBugWorkarounds));
 617   std::string args = command_line.GetSwitchValueASCII(
 618       switches::kGpuDriverBugWorkarounds);
 619   EXPECT_STREQ("5,7", args.c_str());
 620 }
 621
 622 TEST_F(GpuDataManagerImplPrivateTest, BlacklistAllFeatures) {
 623   ScopedGpuDataManagerImplPrivate manager;
 624   EXPECT_EQ(0u, manager->GetBlacklistedFeatureCount());
 625   std::string reason;
 626   EXPECT_TRUE(manager->GpuAccessAllowed(&reason));
 627   EXPECT_TRUE(reason.empty());
 628
 629   const std::string blacklist_json = LONG_STRING_CONST(
 630       {
 631         "name": "gpu blacklist",
 632         "version": "0.1",
 633         "entries": [
 634           {
 635             "id": 1,
 636             "features": [
 637               "all"
 638             ]
 639           }
 640         ]
 641       }
 642   );
 643
 644   GPUInfo gpu_info;
 645   gpu_info.gpu.vendor_id = 0x10de;
 646   gpu_info.gpu.device_id = 0x0640;
 647   manager->InitializeForTesting(blacklist_json, gpu_info);
 648
 649   EXPECT_EQ(static_cast<size_t>(NUMBER_OF_GPU_FEATURE_TYPES),
 650             manager->GetBlacklistedFeatureCount());
 651   // TODO(zmo): remove the Linux specific behavior once we fix
 652   // crbug.com/238466.
 653 #if defined(OS_LINUX)
 654   EXPECT_TRUE(manager->GpuAccessAllowed(&reason));
 655   EXPECT_TRUE(reason.empty());
 656 #else
 657   EXPECT_FALSE(manager->GpuAccessAllowed(&reason));
 658   EXPECT_FALSE(reason.empty());
 659 #endif
 660 }
 661
 662 }  // namespace content