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