Update gpu_test_expectations and use angle_gpu_info_util

src/tests/BUILD.gn

@@ -319,10 +319,8 @@ if (build_angle_deqp_tests) {
     sources = deqp_gypi.deqp_gpu_test_expectations_sources
     sources += [ "//gpu/angle_deqp_tests_main.cc" ]
 
-    # Taken from gpu/BUILD.gn
-    # TODO(jmadill): this should be in a shared location
-    if (is_linux && !is_chromecast) {
-      libs = [ "pci" ]
+    if (!is_android) {
+      public_deps += ["//third_party/angle:angle_gpu_info_util"]
     }
   }
 

src/tests/deqp.gypi

@@ -1806,7 +1806,16 @@
                         'angle_test_support',
                         '<(angle_path)/util/util.gyp:angle_util',
                     ],
-
+                    'conditions':
+                    [
+                        ['OS!="android"',
+                        {
+                            'dependencies':
+                            [
+                                '<(angle_path)/src/angle.gyp:angle_gpu_info_util',
+                            ],
+                        }],
+                    ],
                     'direct_dependent_settings':
                     {
                         'include_dirs':
@@ -1836,35 +1845,15 @@
                                 ],
                             },
                         },
-
                         'conditions':
                         [
-                            # NOTE(smcgruer): Guarding with use_libpci allows gyp to run successfully
-                            # on systems without libpci, but the test targets will not compile or link.
-                            ['OS=="linux" and use_libpci==1',
-                            {
-                                'ldflags':
-                                [
-                                    '<!@(<(pkg-config) --libs-only-L --libs-only-other libpci)',
-                                ],
-                                'libraries':
-                                [
-                                    '<!@(<(pkg-config) --libs-only-l libpci)',
-                                ],
-                            }],
                             ['OS=="mac"',
                             {
                                 'sources':
                                 [
+                                    'third_party/gpu_test_expectations/gpu_test_config_mac.h',
                                     'third_party/gpu_test_expectations/gpu_test_config_mac.mm',
                                 ],
-                                'link_settings':
-                                {
-                                    'libraries':
-                                    [
-                                        '$(SDKROOT)/System/Library/Frameworks/IOKit.framework',
-                                    ],
-                                },
                             }],
                         ],
                     },

src/tests/third_party/gpu_test_expectations/angle-mods.patch

-diff -rupN gpu_test_expectations_reverted/angle_config.h gpu_test_expectations/angle_config.h
+diff -u -rupN gpu_test_expectations_reverted/angle_config.h gpu_test_expectations/angle_config.h
 --- gpu_test_expectations_reverted/angle_config.h	1969-12-31 19:00:00.000000000 -0500
-+++ gpu_test_expectations/angle_config.h	2017-07-19 18:08:09.552231453 -0400
-@@ -0,0 +1,61 @@
++++ gpu_test_expectations/angle_config.h	2017-09-07 13:19:49.903835490 -0400
+@@ -0,0 +1,73 @@
 +//
 +// Copyright 2015 The ANGLE Project Authors. All rights reserved.
 +// Use of this source code is governed by a BSD-style license that can be
@@ -11,8 +11,8 @@ diff -rupN gpu_test_expectations_reverted/angle_config.h gpu_test_expectations/a
 +//   Helpers for importing the gpu test expectations package from Chrome.
 +//
 +
-+#ifndef GPU_TEST_EXPECTATIONS_ANGLE_CONFIG_H_
-+#define GPU_TEST_EXPECTATIONS_ANGLE_CONFIG_H_
++#ifndef ANGLE_GPU_TEST_EXPECTATIONS_ANGLE_CONFIG_H_
++#define ANGLE_GPU_TEST_EXPECTATIONS_ANGLE_CONFIG_H_
 +
 +#include <stdint.h>
 +
@@ -24,16 +24,12 @@ diff -rupN gpu_test_expectations_reverted/angle_config.h gpu_test_expectations/a
 +#define DCHECK_EQ(A,B) ASSERT((A) == (B))
 +#define DCHECK_NE(A,B) ASSERT((A) != (B))
 +#define DCHECK(X) ASSERT(X)
++#define DLOG(X) std::cerr
 +#define LOG(X) std::cerr
 +
 +#define GPU_EXPORT
 +
-+typedef int32_t int32;
-+typedef uint32_t uint32;
-+typedef int64_t int64;
-+typedef uint64_t uint64;
-+
-+// Shim Chromium's base by importing functions in the base namespace.
++// Shim Chromium's types by importing symbols in the correct namespaces
 +namespace base
 +{
 +    using angle::kWhitespaceASCII;
@@ -45,7 +41,23 @@ diff -rupN gpu_test_expectations_reverted/angle_config.h gpu_test_expectations/a
 +    using angle::SplitStringAlongWhitespace;
 +    using angle::HexStringToUInt;
 +    using angle::ReadFileToString;
-+}
++
++    using TimeDelta = int;
++}  // namespace base
++
++namespace gfx
++{
++    class Size
++    {
++      public:
++        int width() const { return 0; }
++        int height() const { return 0; }
++    };
++}  // namespace gfx
++
++struct DxDiagNode
++{
++};
 +
 +// TODO(jmadill): other platforms
 +// clang-format off
@@ -63,126 +75,45 @@ diff -rupN gpu_test_expectations_reverted/angle_config.h gpu_test_expectations/a
 +// clang-format on
 +
 +#endif
-diff -rupN gpu_test_expectations_reverted/gpu_info.cc gpu_test_expectations/gpu_info.cc
---- gpu_test_expectations_reverted/gpu_info.cc	2017-07-19 18:00:16.369751203 -0400
-+++ gpu_test_expectations/gpu_info.cc	2017-05-19 17:51:38.665944833 -0400
-@@ -2,7 +2,7 @@
- // Use of this source code is governed by a BSD-style license that can be
- // found in the LICENSE file.
+diff -u -rupN gpu_test_expectations_reverted/gpu_info.cc gpu_test_expectations/gpu_info.cc
+--- gpu_test_expectations_reverted/gpu_info.cc	2017-09-06 11:43:12.749280785 -0400
++++ gpu_test_expectations/gpu_info.cc	2017-09-07 13:17:55.282894551 -0400
+@@ -4,7 +4,7 @@
+ 
+ #include <stdint.h>
  
 -#include "gpu/config/gpu_info.h"
 +#include "gpu_info.h"
  
  namespace {
  
-@@ -17,31 +17,6 @@ void EnumerateGPUDevice(const gpu::GPUIn
-   enumerator->EndGPUDevice();
+@@ -100,7 +100,7 @@ const GPUInfo::GPUDevice& GPUInfo::activ
+     if (secondary_gpu.active)
+       return secondary_gpu;
+   }
+-  DLOG(ERROR) << "No active GPU found, returning primary GPU.";
++  DLOG(ERROR) << "No active GPU found, returning primary GPU.\n";
+   return gpu;
  }
  
--void EnumerateVideoDecodeAcceleratorSupportedProfile(
--    const gpu::VideoDecodeAcceleratorSupportedProfile& profile,
--    gpu::GPUInfo::Enumerator* enumerator) {
--  enumerator->BeginVideoDecodeAcceleratorSupportedProfile();
--  enumerator->AddInt("profile", profile.profile);
--  enumerator->AddInt("maxResolutionWidth", profile.max_resolution.width());
--  enumerator->AddInt("maxResolutionHeight", profile.max_resolution.height());
--  enumerator->AddInt("minResolutionWidth", profile.min_resolution.width());
--  enumerator->AddInt("minResolutionHeight", profile.min_resolution.height());
--  enumerator->EndVideoDecodeAcceleratorSupportedProfile();
--}
--
--void EnumerateVideoEncodeAcceleratorSupportedProfile(
--    const gpu::VideoEncodeAcceleratorSupportedProfile& profile,
--    gpu::GPUInfo::Enumerator* enumerator) {
--  enumerator->BeginVideoEncodeAcceleratorSupportedProfile();
--  enumerator->AddInt("profile", profile.profile);
--  enumerator->AddInt("maxResolutionWidth", profile.max_resolution.width());
--  enumerator->AddInt("maxResolutionHeight", profile.max_resolution.height());
--  enumerator->AddInt("maxFramerateNumerator", profile.max_framerate_numerator);
--  enumerator->AddInt("maxFramerateDenominator",
--                     profile.max_framerate_denominator);
--  enumerator->EndVideoEncodeAcceleratorSupportedProfile();
--}
--
- }  // namespace
+diff -u -rupN gpu_test_expectations_reverted/gpu_info.h gpu_test_expectations/gpu_info.h
+--- gpu_test_expectations_reverted/gpu_info.h	2017-09-06 11:43:16.229309773 -0400
++++ gpu_test_expectations/gpu_info.h	2017-09-07 13:18:25.187140020 -0400
+@@ -2,8 +2,8 @@
+ // Use of this source code is governed by a BSD-style license that can be
+ // found in the LICENSE file.
  
- namespace gpu {
-@@ -68,9 +43,6 @@ GPUInfo::GPUInfo()
-       in_process_gpu(true),
-       basic_info_state(kCollectInfoNone),
-       context_info_state(kCollectInfoNone),
--#if defined(OS_WIN)
--      dx_diagnostics_info_state(kCollectInfoNone),
--#endif
-       jpeg_decode_accelerator_supported(false) {
- }
+-#ifndef GPU_CONFIG_GPU_INFO_H_
+-#define GPU_CONFIG_GPU_INFO_H_
++#ifndef ANGLE_GPU_CONFIG_GPU_INFO_H_
++#define ANGLE_GPU_CONFIG_GPU_INFO_H_
  
-@@ -78,11 +50,9 @@ GPUInfo::~GPUInfo() { }
- 
- void GPUInfo::EnumerateFields(Enumerator* enumerator) const {
-   struct GPUInfoKnownFields {
--    base::TimeDelta initialization_time;
-     bool optimus;
-     bool amd_switchable;
-     bool lenovo_dcute;
--    Version display_link_version;
-     GPUDevice gpu;
-     std::vector<GPUDevice> secondary_gpus;
-     uint64 adapter_luid;
-@@ -110,14 +80,6 @@ void GPUInfo::EnumerateFields(Enumerator
-     bool in_process_gpu;
-     CollectInfoResult basic_info_state;
-     CollectInfoResult context_info_state;
--#if defined(OS_WIN)
--    CollectInfoResult dx_diagnostics_info_state;
--    DxDiagNode dx_diagnostics;
--#endif
--    VideoDecodeAcceleratorSupportedProfiles
--        video_decode_accelerator_supported_profiles;
--    VideoEncodeAcceleratorSupportedProfiles
--        video_encode_accelerator_supported_profiles;
-     bool jpeg_decode_accelerator_supported;
-   };
- 
-@@ -136,15 +98,9 @@ void GPUInfo::EnumerateFields(Enumerator
-     EnumerateGPUDevice(secondary_gpu, enumerator);
- 
-   enumerator->BeginAuxAttributes();
--  enumerator->AddTimeDeltaInSecondsF("initializationTime",
--                                     initialization_time);
-   enumerator->AddBool("optimus", optimus);
-   enumerator->AddBool("amdSwitchable", amd_switchable);
-   enumerator->AddBool("lenovoDcute", lenovo_dcute);
--  if (display_link_version.IsValid()) {
--    enumerator->AddString("displayLinkVersion",
--                          display_link_version.GetString());
--  }
-   enumerator->AddInt64("adapterLuid", adapter_luid);
-   enumerator->AddString("driverVendor", driver_vendor);
-   enumerator->AddString("driverVersion", driver_version);
-@@ -171,14 +127,7 @@ void GPUInfo::EnumerateFields(Enumerator
-   enumerator->AddBool("inProcessGpu", in_process_gpu);
-   enumerator->AddInt("basicInfoState", basic_info_state);
-   enumerator->AddInt("contextInfoState", context_info_state);
--#if defined(OS_WIN)
--  enumerator->AddInt("DxDiagnosticsInfoState", dx_diagnostics_info_state);
--#endif
-   // TODO(kbr): add dx_diagnostics on Windows.
--  for (const auto& profile : video_decode_accelerator_supported_profiles)
--    EnumerateVideoDecodeAcceleratorSupportedProfile(profile, enumerator);
--  for (const auto& profile : video_encode_accelerator_supported_profiles)
--    EnumerateVideoEncodeAcceleratorSupportedProfile(profile, enumerator);
-   enumerator->AddBool("jpegDecodeAcceleratorSupported",
-       jpeg_decode_accelerator_supported);
-   enumerator->EndAuxAttributes();
-diff -rupN gpu_test_expectations_reverted/gpu_info.h gpu_test_expectations/gpu_info.h
---- gpu_test_expectations_reverted/gpu_info.h	2017-07-19 18:00:16.369751203 -0400
-+++ gpu_test_expectations/gpu_info.h	2017-05-19 17:51:38.665944833 -0400
-@@ -11,13 +11,7 @@
+ // Provides access to the GPU information for the system
+ // on which chrome is currently running.
+@@ -13,12 +13,7 @@
  #include <string>
  #include <vector>
  
--#include "base/basictypes.h"
 -#include "base/time/time.h"
 -#include "base/version.h"
 -#include "build/build_config.h"
@@ -191,93 +122,27 @@ diff -rupN gpu_test_expectations_reverted/gpu_info.h gpu_test_expectations/gpu_i
 -#include "ui/gfx/geometry/size.h"
 +#include "angle_config.h"
  
- namespace gpu {
- 
-@@ -54,25 +48,6 @@ enum VideoCodecProfile {
-   VIDEO_CODEC_PROFILE_MAX = VP9PROFILE_ANY,
- };
+ #if defined(USE_X11)
+ typedef unsigned long VisualID;
+@@ -301,4 +296,4 @@ struct GPU_EXPORT GPUInfo {
  
--// Specification of a decoding profile supported by a hardware decoder.
--struct GPU_EXPORT VideoDecodeAcceleratorSupportedProfile {
--  VideoCodecProfile profile;
--  gfx::Size max_resolution;
--  gfx::Size min_resolution;
--};
--using VideoDecodeAcceleratorSupportedProfiles =
--    std::vector<VideoDecodeAcceleratorSupportedProfile>;
--
--// Specification of an encoding profile supported by a hardware encoder.
--struct GPU_EXPORT VideoEncodeAcceleratorSupportedProfile {
--  VideoCodecProfile profile;
--  gfx::Size max_resolution;
--  uint32 max_framerate_numerator;
--  uint32 max_framerate_denominator;
--};
--using VideoEncodeAcceleratorSupportedProfiles =
--    std::vector<VideoEncodeAcceleratorSupportedProfile>;
--
- struct GPU_EXPORT GPUInfo {
-   struct GPU_EXPORT GPUDevice {
-     GPUDevice();
-@@ -104,10 +79,6 @@ struct GPU_EXPORT GPUInfo {
-     return !can_lose_context && !software_rendering;
-   }
+ }  // namespace gpu
  
--  // The amount of time taken to get from the process starting to the message
--  // loop being pumped.
--  base::TimeDelta initialization_time;
--
-   // Computer has NVIDIA Optimus
-   bool optimus;
- 
-@@ -117,10 +88,6 @@ struct GPU_EXPORT GPUInfo {
-   // Lenovo dCute is installed. http://crbug.com/181665.
-   bool lenovo_dcute;
- 
--  // Version of DisplayLink driver installed. Zero if not installed.
--  // http://crbug.com/177611.
--  Version display_link_version;
--
-   // Primary GPU, for exmaple, the discrete GPU in a dual GPU machine.
-   GPUDevice gpu;
- 
-@@ -213,17 +180,7 @@ struct GPU_EXPORT GPUInfo {
-   // if the collection fails or not.
-   CollectInfoResult basic_info_state;
-   CollectInfoResult context_info_state;
--#if defined(OS_WIN)
--  CollectInfoResult dx_diagnostics_info_state;
- 
--  // The information returned by the DirectX Diagnostics Tool.
--  DxDiagNode dx_diagnostics;
--#endif
--
--  VideoDecodeAcceleratorSupportedProfiles
--      video_decode_accelerator_supported_profiles;
--  VideoEncodeAcceleratorSupportedProfiles
--      video_encode_accelerator_supported_profiles;
-   bool jpeg_decode_accelerator_supported;
- 
-   // Note: when adding new members, please remember to update EnumerateFields
-@@ -243,8 +200,6 @@ struct GPU_EXPORT GPUInfo {
-     virtual void AddInt(const char* name, int value) = 0;
-     virtual void AddString(const char* name, const std::string& value) = 0;
-     virtual void AddBool(const char* name, bool value) = 0;
--    virtual void AddTimeDeltaInSecondsF(const char* name,
--                                        const base::TimeDelta& value) = 0;
- 
-     // Markers indicating that a GPUDevice is being described.
-     virtual void BeginGPUDevice() = 0;
-diff -rupN gpu_test_expectations_reverted/gpu_test_config.cc gpu_test_expectations/gpu_test_config.cc
---- gpu_test_expectations_reverted/gpu_test_config.cc	2017-07-19 18:00:16.369751203 -0400
-+++ gpu_test_expectations/gpu_test_config.cc	2017-05-19 18:24:51.028549550 -0400
-@@ -2,20 +2,205 @@
+-#endif  // GPU_CONFIG_GPU_INFO_H_
++#endif  // ANGLE_GPU_CONFIG_GPU_INFO_H_
+diff -u -rupN gpu_test_expectations_reverted/gpu_test_config.cc gpu_test_expectations/gpu_test_config.cc
+--- gpu_test_expectations_reverted/gpu_test_config.cc	2017-09-06 11:43:27.173400936 -0400
++++ gpu_test_expectations/gpu_test_config.cc	2017-09-07 13:17:55.282894551 -0400
+@@ -2,21 +2,53 @@
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  
 -#include "gpu/config/gpu_test_config.h"
 +#include "gpu_test_config.h"
  
+ #include <stddef.h>
+ #include <stdint.h>
+ 
 -#include "base/logging.h"
 -#include "base/sys_info.h"
 -#include "gpu/config/gpu_info.h"
@@ -285,26 +150,20 @@ diff -rupN gpu_test_expectations_reverted/gpu_test_config.cc gpu_test_expectatio
 -#include "gpu/config/gpu_test_expectations_parser.h"
 +#include "gpu_info.h"
 +#include "gpu_test_expectations_parser.h"
-+
-+#if defined(OS_LINUX)
-+extern "C" {
-+#   include <pci/pci.h>
-+}
-+#endif
  
- #if defined(OS_MACOSX)
--#include "base/mac/mac_util.h"
--#elif defined(OS_WIN)
+-#if defined(OS_WIN)
 -#include "base/win/windows_version.h"
++#if defined(OS_MACOSX)
 +#include "gpu_test_config_mac.h"
 +#endif
 +
-+using namespace gpu;
-+
++#if !defined(OS_ANDROID)
++#include "gpu_info_util/SystemInfo.h"
+ #endif
+ 
 +#if defined(OS_WIN)
 +
 +namespace base {
-+
 +namespace {
 +
 +// Disable the deprecated function warning for GetVersionEx
@@ -314,12 +173,12 @@ diff -rupN gpu_test_expectations_reverted/gpu_test_config.cc gpu_test_expectatio
 +{
 +  public:
 +    static void OperatingSystemVersionNumbers(
-+        int32 *major_version, int32 *minor_version, int32 *bugfix_version);
++        int32_t *major_version, int32_t *minor_version, int32_t *bugfix_version);
 +};
 +
 +// static
 +void SysInfo::OperatingSystemVersionNumbers(
-+    int32 *major_version, int32 *minor_version, int32 *bugfix_version)
++    int32_t *major_version, int32_t *minor_version, int32_t *bugfix_version)
 +{
 +  OSVERSIONINFOEX version_info = { sizeof version_info };
 +  ::GetVersionEx(reinterpret_cast<OSVERSIONINFO*>(&version_info));
@@ -329,278 +188,92 @@ diff -rupN gpu_test_expectations_reverted/gpu_test_config.cc gpu_test_expectatio
 +}
 +
 +} // anonymous namespace
-+
 +} // namespace base
 +
-+void DeviceIDToVendorAndDevice(const std::string& id,
-+                               uint32* vendor_id,
-+                               uint32* device_id) {
-+  *vendor_id = 0;
-+  *device_id = 0;
-+  if (id.length() < 21)
-+    return;
-+  std::string vendor_id_string = id.substr(8, 4);
-+  std::string device_id_string = id.substr(17, 4);
-+  base::HexStringToUInt(vendor_id_string, vendor_id);
-+  base::HexStringToUInt(device_id_string, device_id);
-+}
-+
-+CollectInfoResult CollectGpuID(uint32* vendor_id, uint32* device_id) {
-+  DCHECK(vendor_id && device_id);
-+  *vendor_id = 0;
-+  *device_id = 0;
-+
-+  // Taken from http://developer.nvidia.com/object/device_ids.html
-+  DISPLAY_DEVICEA dd;
-+  dd.cb = sizeof(DISPLAY_DEVICEA);
-+  std::string id;
-+  for (int i = 0; EnumDisplayDevicesA(NULL, i, &dd, 0); ++i) {
-+    if (dd.StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE) {
-+      id = dd.DeviceID;
-+      break;
-+    }
-+  }
-+
-+  if (id.length() > 20) {
-+    DeviceIDToVendorAndDevice(id, vendor_id, device_id);
-+    if (*vendor_id != 0 && *device_id != 0)
-+      return kCollectInfoSuccess;
-+  }
-+  return kCollectInfoNonFatalFailure;
-+}
-+
 +#endif // defined(OS_WIN)
 +
-+#if defined(OS_LINUX)
-+
-+const uint32 kVendorIDIntel = 0x8086;
-+const uint32 kVendorIDNVidia = 0x10de;
-+const uint32 kVendorIDAMD = 0x1002;
-+
-+CollectInfoResult CollectPCIVideoCardInfo(GPUInfo* gpu_info) {
-+  DCHECK(gpu_info);
-+
-+  struct pci_access* access = pci_alloc();
-+  DCHECK(access != NULL);
-+  pci_init(access);
-+  pci_scan_bus(access);
-+
-+  bool primary_gpu_identified = false;
-+  for (pci_dev* device = access->devices;
-+       device != NULL; device = device->next) {
-+    pci_fill_info(device, 33);
-+    bool is_gpu = false;
-+    switch (device->device_class) {
-+      case PCI_CLASS_DISPLAY_VGA:
-+      case PCI_CLASS_DISPLAY_XGA:
-+      case PCI_CLASS_DISPLAY_3D:
-+        is_gpu = true;
-+        break;
-+      case PCI_CLASS_DISPLAY_OTHER:
-+      default:
-+        break;
-+    }
-+    if (!is_gpu)
-+      continue;
-+    if (device->vendor_id == 0 || device->device_id == 0)
-+      continue;
-+
-+    GPUInfo::GPUDevice gpu;
-+    gpu.vendor_id = device->vendor_id;
-+    gpu.device_id = device->device_id;
-+
-+    if (!primary_gpu_identified) {
-+      primary_gpu_identified = true;
-+      gpu_info->gpu = gpu;
-+    } else {
-+      // TODO(zmo): if there are multiple GPUs, we assume the non Intel
-+      // one is primary. Revisit this logic because we actually don't know
-+      // which GPU we are using at this point.
-+      if (gpu_info->gpu.vendor_id == kVendorIDIntel &&
-+          gpu.vendor_id != kVendorIDIntel) {
-+        gpu_info->secondary_gpus.push_back(gpu_info->gpu);
-+        gpu_info->gpu = gpu;
-+      } else {
-+        gpu_info->secondary_gpus.push_back(gpu);
-+      }
-+    }
-+  }
-+
-+  // Detect Optimus or AMD Switchable GPU.
-+  if (gpu_info->secondary_gpus.size() == 1 &&
-+      gpu_info->secondary_gpus[0].vendor_id == kVendorIDIntel) {
-+    if (gpu_info->gpu.vendor_id == kVendorIDNVidia)
-+      gpu_info->optimus = true;
-+    if (gpu_info->gpu.vendor_id == kVendorIDAMD)
-+      gpu_info->amd_switchable = true;
+ namespace gpu {
+ 
+ namespace {
+@@ -74,6 +106,26 @@ GPUTestConfig::OS GetCurrentOS() {
+   return GPUTestConfig::kOsUnknown;
+ }
+ 
++#if !defined(OS_ANDROID)
++CollectInfoResult CollectBasicGraphicsInfo(GPUInfo* gpu_info) {
++  angle::SystemInfo info;
++  if (!angle::GetSystemInfo(&info)) {
++    return kCollectInfoFatalFailure;
 +  }
-+
-+  pci_cleanup(access);
-+  if (!primary_gpu_identified)
-+    return kCollectInfoNonFatalFailure;
++  const angle::GPUDeviceInfo& gpu = info.gpus[info.primaryGPUIndex];
++  gpu_info->gpu.vendor_id = gpu.vendorId;
++  gpu_info->gpu.device_id = gpu.deviceId;
++  gpu_info->gpu.active = true;
 +  return kCollectInfoSuccess;
 +}
-+
-+CollectInfoResult CollectGpuID(uint32* vendor_id, uint32* device_id) {
-+  DCHECK(vendor_id && device_id);
-+  *vendor_id = 0;
-+  *device_id = 0;
-+
-+  GPUInfo gpu_info;
-+  CollectInfoResult result = CollectPCIVideoCardInfo(&gpu_info);
-+  if (result == kCollectInfoSuccess) {
-+    *vendor_id = gpu_info.gpu.vendor_id;
-+    *device_id = gpu_info.gpu.device_id;
-+  }
-+  return result;
-+}
-+
-+#endif // defined(OS_LINUX)
-+
-+#if defined(OS_MACOSX)
-+
-+CollectInfoResult CollectGpuID(uint32* vendor_id, uint32* device_id) {
-+  DCHECK(vendor_id && device_id);
-+
-+  GPUInfo::GPUDevice gpu = GetActiveGPU();
-+  *vendor_id = gpu.vendor_id;
-+  *device_id = gpu.device_id;
-+
-+  if (*vendor_id != 0 && *device_id != 0)
-+    return kCollectInfoSuccess;
++#else
++CollectInfoResult CollectBasicGraphicsInfo(GPUInfo* gpu_info) {
++  gpu_info->gpu.vendor_id = 0;
++  gpu_info->gpu.device_id = 0;
++  gpu_info->gpu.active = true;
 +  return kCollectInfoNonFatalFailure;
 +}
-+
- #endif
- 
-+#if defined(OS_ANDROID)
-+CollectInfoResult CollectGpuID(uint32 *vendor_id, uint32 *device_id)
-+{
-+    DCHECK(vendor_id && device_id);
-+    *vendor_id = 0;
-+    *device_id = 0;
-+    return kCollectInfoNonFatalFailure;
-+}
 +#endif  // defined(OS_ANDROID)
-+
- namespace gpu {
- 
- namespace {
-@@ -245,33 +430,41 @@ bool GPUTestBotConfig::Matches(const std
-   return Matches(config);
- }
+ }  // namespace anonymous
  
--bool GPUTestBotConfig::LoadCurrentConfig(const GPUInfo* gpu_info) {
--  bool rt;
--  if (gpu_info == NULL) {
--    GPUInfo my_gpu_info;
--    CollectInfoResult result = CollectGpuID(
--        &my_gpu_info.gpu.vendor_id, &my_gpu_info.gpu.device_id);
--    if (result != kCollectInfoSuccess) {
+ GPUTestConfig::GPUTestConfig()
+@@ -257,7 +309,7 @@ bool GPUTestBotConfig::LoadCurrentConfig
+     GPUInfo my_gpu_info;
+     CollectInfoResult result = CollectBasicGraphicsInfo(&my_gpu_info);
+     if (result != kCollectInfoSuccess) {
 -      LOG(ERROR) << "Fail to identify GPU";
--      DisableGPUInfoValidation();
--      rt = true;
--    } else {
--      rt = SetGPUInfo(my_gpu_info);
-+bool GPUTestBotConfig::LoadCurrentConfig(const GPUInfo *gpu_info)
-+{
-+    bool rt;
-+    if (gpu_info == NULL)
-+    {
-+        GPUInfo my_gpu_info;
-+        CollectInfoResult result =
-+            CollectGpuID(&my_gpu_info.gpu.vendor_id, &my_gpu_info.gpu.device_id);
-+        if (result != kCollectInfoSuccess)
-+        {
-+            LOG(ERROR) << "Fail to identify GPU\n";
-+            DisableGPUInfoValidation();
-+            rt = true;
-+        }
-+        else
-+        {
-+            rt = SetGPUInfo(my_gpu_info);
-+        }
-+    }
-+    else
-+    {
-+        rt = SetGPUInfo(*gpu_info);
-+    }
-+    set_os(GetCurrentOS());
-+    if (os() == kOsUnknown)
-+    {
-+        LOG(ERROR) << "Unknown OS\n";
-+        rt = false;
-     }
--  } else {
--    rt = SetGPUInfo(*gpu_info);
--  }
--  set_os(GetCurrentOS());
--  if (os() == kOsUnknown) {
++      LOG(ERROR) << "Fail to identify GPU\n";
+       DisableGPUInfoValidation();
+       rt = true;
+     } else {
+@@ -268,7 +320,7 @@ bool GPUTestBotConfig::LoadCurrentConfig
+   }
+   set_os(GetCurrentOS());
+   if (os() == kOsUnknown) {
 -    LOG(ERROR) << "Unknown OS";
--    rt = false;
--  }
++    LOG(ERROR) << "Unknown OS\n";
+     rt = false;
+   }
  #if defined(NDEBUG)
--  set_build_type(kBuildTypeRelease);
-+    set_build_type(kBuildTypeRelease);
- #else
--  set_build_type(kBuildTypeDebug);
-+    set_build_type(kBuildTypeDebug);
- #endif
--  return rt;
-+    return rt;
- }
+diff -u -rupN gpu_test_expectations_reverted/gpu_test_config.h gpu_test_expectations/gpu_test_config.h
+--- gpu_test_expectations_reverted/gpu_test_config.h	2017-09-06 11:43:24.205376213 -0400
++++ gpu_test_expectations/gpu_test_config.h	2017-09-07 13:18:46.207312571 -0400
+@@ -2,16 +2,15 @@
+ // Use of this source code is governed by a BSD-style license that can be
+ // found in the LICENSE file.
  
- // static
-@@ -295,21 +488,5 @@ bool GPUTestBotConfig::CurrentConfigMatc
-   return false;
- }
+-#ifndef GPU_CONFIG_GPU_TEST_CONFIG_H_
+-#define GPU_CONFIG_GPU_TEST_CONFIG_H_
++#ifndef ANGLE_GPU_CONFIG_GPU_TEST_CONFIG_H_
++#define ANGLE_GPU_CONFIG_GPU_TEST_CONFIG_H_
  
--// static
--bool GPUTestBotConfig::GpuBlacklistedOnBot() {
--#if defined(OS_MACOSX)
--  // Blacklist rule #81 disables all Gpu acceleration on Mac < 10.8 bots.
--  if (CurrentConfigMatches("MAC VMWARE") && base::mac::IsOSLionOrEarlier()) {
--    return true;
--  }
--#elif defined(OS_WIN)
--  // Blacklist rule #79 disables all Gpu acceleration before Windows 7.
--  if (base::win::GetVersion() <= base::win::VERSION_VISTA) {
--    return true;
--  }
--#endif
--  return false;
--}
--
- }  // namespace gpu
+ #include <stdint.h>
  
-diff -rupN gpu_test_expectations_reverted/gpu_test_config.h gpu_test_expectations/gpu_test_config.h
---- gpu_test_expectations_reverted/gpu_test_config.h	2017-07-19 18:00:16.369751203 -0400
-+++ gpu_test_expectations/gpu_test_config.h	2017-05-19 17:51:38.665944833 -0400
-@@ -8,9 +8,7 @@
  #include <string>
  #include <vector>
  
--#include "base/basictypes.h"
 -#include "base/compiler_specific.h"
 -#include "gpu/gpu_export.h"
 +#include "angle_config.h"
  
  namespace gpu {
  
-@@ -134,9 +132,6 @@ class GPU_EXPORT GPUTestBotConfig : publ
-   // Check if this bot's config matches |config_data| or any of the |configs|.
-   static bool CurrentConfigMatches(const std::string& config_data);
-   static bool CurrentConfigMatches(const std::vector<std::string>& configs);
--
--  // Check if the bot has blacklisted all GPU features.
--  static bool GpuBlacklistedOnBot();
- };
+@@ -144,5 +143,5 @@ class GPU_EXPORT GPUTestBotConfig : publ
  
  }  // namespace gpu
-diff -rupN gpu_test_expectations_reverted/gpu_test_config_mac.h gpu_test_expectations/gpu_test_config_mac.h
+ 
+-#endif  // GPU_CONFIG_GPU_TEST_CONFIG_H_
++#endif  // ANGLE_GPU_CONFIG_GPU_TEST_CONFIG_H_
+ 
+diff -u -rupN gpu_test_expectations_reverted/gpu_test_config_mac.h gpu_test_expectations/gpu_test_config_mac.h
 --- gpu_test_expectations_reverted/gpu_test_config_mac.h	1969-12-31 19:00:00.000000000 -0500
-+++ gpu_test_expectations/gpu_test_config_mac.h	2017-05-19 17:51:38.665944833 -0400
-@@ -0,0 +1,28 @@
++++ gpu_test_expectations/gpu_test_config_mac.h	2017-09-07 13:19:06.823481813 -0400
+@@ -0,0 +1,27 @@
 +//
 +// Copyright 2015 The ANGLE Project Authors. All rights reserved.
 +// Use of this source code is governed by a BSD-style license that can be
@@ -610,8 +283,8 @@ diff -rupN gpu_test_expectations_reverted/gpu_test_config_mac.h gpu_test_expecta
 +//   Helper functions for gpu_test_config that have to be compiled in ObjectiveC++
 +//
 +
-+#ifndef GPU_TEST_EXPECTATIONS_GPU_TEST_CONFIG_MAC_H_
-+#define GPU_TEST_EXPECTATIONS_GPU_TEST_CONFIG_MAC_H_
++#ifndef ANGLE_GPU_TEST_EXPECTATIONS_GPU_TEST_CONFIG_MAC_H_
++#define ANGLE_GPU_TEST_EXPECTATIONS_GPU_TEST_CONFIG_MAC_H_
 +
 +#include "gpu_info.h"
 +
@@ -620,19 +293,18 @@ diff -rupN gpu_test_expectations_reverted/gpu_test_config_mac.h gpu_test_expecta
 +class SysInfo
 +{
 +  public:
-+    static void OperatingSystemVersionNumbers(
-+        int32 *major_version, int32 *minor_version, int32 *bugfix_version);
++    static void OperatingSystemVersionNumbers(int32_t *major_version,
++                                              int32_t *minor_version,
++                                              int32_t *bugfix_version);
 +};
 +
 +} // namespace base
 +
-+gpu::GPUInfo::GPUDevice GetActiveGPU();
-+
-+#endif // GPU_TEST_EXPECTATIONS_GPU_TEST_CONFIG_MAC_H_
-diff -rupN gpu_test_expectations_reverted/gpu_test_config_mac.mm gpu_test_expectations/gpu_test_config_mac.mm
++#endif // ANGLE_GPU_TEST_EXPECTATIONS_GPU_TEST_CONFIG_MAC_H_
+diff -u -rupN gpu_test_expectations_reverted/gpu_test_config_mac.mm gpu_test_expectations/gpu_test_config_mac.mm
 --- gpu_test_expectations_reverted/gpu_test_config_mac.mm	1969-12-31 19:00:00.000000000 -0500
-+++ gpu_test_expectations/gpu_test_config_mac.mm	2017-05-19 18:24:51.028549550 -0400
-@@ -0,0 +1,75 @@
++++ gpu_test_expectations/gpu_test_config_mac.mm	2017-09-07 13:17:55.282894551 -0400
+@@ -0,0 +1,38 @@
 +// 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.
@@ -654,8 +326,9 @@ diff -rupN gpu_test_expectations_reverted/gpu_test_config_mac.mm gpu_test_expect
 +@end
 +#endif
 +
-+void SysInfo::OperatingSystemVersionNumbers(
-+    int32 *major_version, int32 *minor_version, int32 *bugfix_version)
++void SysInfo::OperatingSystemVersionNumbers(int32_t *major_version,
++                                            int32_t *minor_version,
++                                            int32_t *bugfix_version)
 +{
 +#if MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_8
 +  Gestalt(gestaltSystemVersionMajor, reinterpret_cast<SInt32*>(major_version));
@@ -670,62 +343,26 @@ diff -rupN gpu_test_expectations_reverted/gpu_test_config_mac.mm gpu_test_expect
 +}
 +
 +} // namespace base
-+
-+UInt32 GetEntryProperty(io_registry_entry_t entry, CFStringRef property_name) {
-+  CFTypeRef type = IORegistryEntrySearchCFProperty(entry,
-+                                                   kIOServicePlane,
-+                                                   property_name,
-+                                                   kCFAllocatorDefault,
-+                                                   kIORegistryIterateRecursively | kIORegistryIterateParents);
-+  CFDataRef data = reinterpret_cast<CFDataRef>(type);
-+  if (!data) {
-+    CFRelease(data);
-+    return 0;
-+  }
-+
-+  UInt32 value = 0;
-+  const uint32_t* valuePointer = reinterpret_cast<const uint32_t*>(CFDataGetBytePtr(data));
-+  if (valuePointer != NULL) {
-+    value = *valuePointer;
-+  }
-+  CFRelease(data);
-+  return value;
-+}
-+
-+gpu::GPUInfo::GPUDevice GetActiveGPU() {
-+  gpu::GPUInfo::GPUDevice gpu;
-+
-+  // Ignore the fact that CGDisplayIOServicePort is deprecated as Apple
-+  // did not provide a good replacement for it as of 10.10.
-+  // TODO(cwallez) revisit with later systems
-+  #pragma clang diagnostic push
-+  #pragma clang diagnostic ignored "-Wdeprecated-declarations"
-+    io_registry_entry_t dsp_port = CGDisplayIOServicePort(kCGDirectMainDisplay);
-+  #pragma clang diagnostic pop
-+
-+  gpu.vendor_id = GetEntryProperty(dsp_port, CFSTR("vendor-id"));
-+  gpu.device_id = GetEntryProperty(dsp_port, CFSTR("device-id"));
-+  return gpu;
-+}
-+
-diff -rupN gpu_test_expectations_reverted/gpu_test_expectations_parser.cc gpu_test_expectations/gpu_test_expectations_parser.cc
---- gpu_test_expectations_reverted/gpu_test_expectations_parser.cc	2017-07-19 18:00:16.369751203 -0400
-+++ gpu_test_expectations/gpu_test_expectations_parser.cc	2017-07-19 18:56:42.954781389 -0400
-@@ -2,14 +2,45 @@
+diff -u -rupN gpu_test_expectations_reverted/gpu_test_expectations_parser.cc gpu_test_expectations/gpu_test_expectations_parser.cc
+--- gpu_test_expectations_reverted/gpu_test_expectations_parser.cc	2017-09-06 11:43:34.317460444 -0400
++++ gpu_test_expectations/gpu_test_expectations_parser.cc	2017-09-07 13:17:55.282894551 -0400
+@@ -2,17 +2,47 @@
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  
 -#include "gpu/config/gpu_test_expectations_parser.h"
 +#include "gpu_test_expectations_parser.h"
  
+ #include <stddef.h>
+ #include <stdint.h>
+ 
 -#include "base/files/file_util.h"
 -#include "base/logging.h"
 -#include "base/strings/string_number_conversions.h"
 -#include "base/strings/string_split.h"
 -#include "base/strings/string_util.h"
 -#include "base/strings/stringprintf.h"
-+#include <sstream>
-+
++#include "angle_config.h"
 +#include "common/angleutils.h"
 +
 +namespace base {
@@ -764,7 +401,7 @@ diff -rupN gpu_test_expectations_reverted/gpu_test_expectations_parser.cc gpu_te
  
  namespace gpu {
  
-@@ -146,9 +177,9 @@ const char* kErrorMessage[] = {
+@@ -151,9 +181,9 @@ const char* kErrorMessage[] = {
  };
  
  Token ParseToken(const std::string& word) {
@@ -775,23 +412,8 @@ diff -rupN gpu_test_expectations_reverted/gpu_test_expectations_parser.cc gpu_te
 +  if (base::StartsWithASCII(word, "0x", false))
      return kConfigGPUDeviceID;
  
-   for (int32 i = 0; i < kNumberOfExactMatchTokens; ++i) {
-@@ -176,10 +207,10 @@ bool NamesMatching(const std::string& re
- 
- GPUTestExpectationsParser::GPUTestExpectationsParser() {
-   // Some sanity check.
--  DCHECK_EQ(static_cast<unsigned int>(kNumberOfExactMatchTokens),
--            sizeof(kTokenData) / sizeof(kTokenData[0]));
--  DCHECK_EQ(static_cast<unsigned int>(kNumberOfErrors),
--            sizeof(kErrorMessage) / sizeof(kErrorMessage[0]));
-+  static_assert(static_cast<unsigned int>(kNumberOfExactMatchTokens) ==
-+                sizeof(kTokenData) / sizeof(kTokenData[0]), "sanity check");
-+  static_assert(static_cast<unsigned int>(kNumberOfErrors) ==
-+                sizeof(kErrorMessage) / sizeof(kErrorMessage[0]), "sanity check");
- }
- 
- GPUTestExpectationsParser::~GPUTestExpectationsParser() {
-@@ -204,8 +235,8 @@ bool GPUTestExpectationsParser::LoadTest
+   for (int32_t i = 0; i < kNumberOfExactMatchTokens; ++i) {
+@@ -209,8 +239,8 @@ bool GPUTestExpectationsParser::LoadTest
    return rt;
  }
  
@@ -802,34 +424,15 @@ diff -rupN gpu_test_expectations_reverted/gpu_test_expectations_parser.cc gpu_te
    entries_.clear();
    error_messages_.clear();
  
-@@ -399,7 +430,7 @@ bool GPUTestExpectationsParser::ParseLin
-           stage++;
-         break;
-       default:
--        DCHECK(false);
-+        UNREACHABLE();
-         break;
-     }
-   }
-@@ -488,7 +519,7 @@ bool GPUTestExpectationsParser::UpdateTe
-       config->set_api(config->api() | kTokenData[token].flag);
-       break;
-     default:
--      DCHECK(false);
-+      UNREACHABLE();
-       break;
-   }
-   return true;
-@@ -529,20 +560,18 @@ bool GPUTestExpectationsParser::DetectCo
+@@ -537,20 +567,17 @@ bool GPUTestExpectationsParser::DetectCo
  
  void GPUTestExpectationsParser::PushErrorMessage(
      const std::string& message, size_t line_number) {
 -  error_messages_.push_back(
 -      base::StringPrintf("Line %d : %s",
 -                         static_cast<int>(line_number), message.c_str()));
-+    std::ostringstream stream;
-+    stream << "Line " << line_number << " : " << message;
-+    error_messages_.push_back(stream.str());
++  error_messages_.push_back("Line " + ToString(line_number) +
++                            " : " + message.c_str());
  }
  
  void GPUTestExpectationsParser::PushErrorMessage(
@@ -841,20 +444,30 @@ diff -rupN gpu_test_expectations_reverted/gpu_test_expectations_parser.cc gpu_te
 -                         static_cast<int>(entry1_line_number),
 -                         static_cast<int>(entry2_line_number),
 -                         message.c_str()));
-+    std::ostringstream stream;
-+    stream << "Line " << entry1_line_number << " and " << entry2_line_number << " : " << message;
-+    error_messages_.push_back(stream.str());
++  error_messages_.push_back("Line " + ToString(entry1_line_number) +
++                            " and " + ToString(entry2_line_number) +
++                            " : " + message.c_str());
  }
  
  GPUTestExpectationsParser:: GPUTestExpectationEntry::GPUTestExpectationEntry()
-diff -rupN gpu_test_expectations_reverted/gpu_test_expectations_parser.h gpu_test_expectations/gpu_test_expectations_parser.h
---- gpu_test_expectations_reverted/gpu_test_expectations_parser.h	2017-07-19 18:00:16.369751203 -0400
-+++ gpu_test_expectations/gpu_test_expectations_parser.h	2017-05-19 17:51:38.665944833 -0400
-@@ -8,10 +8,8 @@
+diff -u -rupN gpu_test_expectations_reverted/gpu_test_expectations_parser.h gpu_test_expectations/gpu_test_expectations_parser.h
+--- gpu_test_expectations_reverted/gpu_test_expectations_parser.h	2017-09-06 11:43:37.229484701 -0400
++++ gpu_test_expectations/gpu_test_expectations_parser.h	2017-09-07 13:19:27.383650602 -0400
+@@ -2,8 +2,8 @@
+ // Use of this source code is governed by a BSD-style license that can be
+ // found in the LICENSE file.
+ 
+-#ifndef GPU_CONFIG_GPU_TEST_EXPECTATIONS_PARSER_H_
+-#define GPU_CONFIG_GPU_TEST_EXPECTATIONS_PARSER_H_
++#ifndef ANGLE_GPU_CONFIG_GPU_TEST_EXPECTATIONS_PARSER_H_
++#define ANGLE_GPU_CONFIG_GPU_TEST_EXPECTATIONS_PARSER_H_
+ 
+ #include <stddef.h>
+ #include <stdint.h>
+@@ -11,9 +11,8 @@
  #include <string>
  #include <vector>
  
--#include "base/basictypes.h"
 -#include "base/files/file_path.h"
 -#include "gpu/config/gpu_test_config.h"
 -#include "gpu/gpu_export.h"
@@ -863,7 +476,7 @@ diff -rupN gpu_test_expectations_reverted/gpu_test_expectations_parser.h gpu_tes
  
  namespace gpu {
  
-@@ -32,7 +30,7 @@ class GPU_EXPORT GPUTestExpectationsPars
+@@ -34,7 +33,7 @@ class GPU_EXPORT GPUTestExpectationsPars
    // save all the entries. Otherwise, generate error messages.
    // Return true if parsing succeeds.
    bool LoadTestExpectations(const std::string& data);
@@ -872,9 +485,16 @@ diff -rupN gpu_test_expectations_reverted/gpu_test_expectations_parser.h gpu_tes
  
    // Query error messages from the last LoadTestExpectations() call.
    const std::vector<std::string>& GetErrorMessages() const;
-diff -rupN gpu_test_expectations_reverted/HowToMakeChanges.md gpu_test_expectations/HowToMakeChanges.md
+@@ -87,5 +86,5 @@ class GPU_EXPORT GPUTestExpectationsPars
+ 
+ }  // namespace gpu
+ 
+-#endif  // GPU_CONFIG_GPU_TEST_EXPECTATIONS_PARSER_H_
++#endif  // ANGLE_GPU_CONFIG_GPU_TEST_EXPECTATIONS_PARSER_H_
+ 
+diff -u -rupN gpu_test_expectations_reverted/HowToMakeChanges.md gpu_test_expectations/HowToMakeChanges.md
 --- gpu_test_expectations_reverted/HowToMakeChanges.md	1969-12-31 19:00:00.000000000 -0500
-+++ gpu_test_expectations/HowToMakeChanges.md	2017-05-19 18:24:51.024549569 -0400
++++ gpu_test_expectations/HowToMakeChanges.md	2017-09-06 11:40:47.432070186 -0400
 @@ -0,0 +1,22 @@
 +Because the ```gpu_test_expectations``` directory is based on parts of Chromium's ```gpu/config```
 +directory, we want to keep a patch of the changes added to make it compile with ANGLE. This

src/tests/third_party/gpu_test_expectations/angle_config.h

@@ -7,8 +7,8 @@
 //   Helpers for importing the gpu test expectations package from Chrome.
 //
 
-#ifndef GPU_TEST_EXPECTATIONS_ANGLE_CONFIG_H_
-#define GPU_TEST_EXPECTATIONS_ANGLE_CONFIG_H_
+#ifndef ANGLE_GPU_TEST_EXPECTATIONS_ANGLE_CONFIG_H_
+#define ANGLE_GPU_TEST_EXPECTATIONS_ANGLE_CONFIG_H_
 
 #include <stdint.h>
 
@@ -20,16 +20,12 @@
 #define DCHECK_EQ(A,B) ASSERT((A) == (B))
 #define DCHECK_NE(A,B) ASSERT((A) != (B))
 #define DCHECK(X) ASSERT(X)
+#define DLOG(X) std::cerr
 #define LOG(X) std::cerr
 
 #define GPU_EXPORT
 
-typedef int32_t int32;
-typedef uint32_t uint32;
-typedef int64_t int64;
-typedef uint64_t uint64;
-
-// Shim Chromium's base by importing functions in the base namespace.
+// Shim Chromium's types by importing symbols in the correct namespaces
 namespace base
 {
     using angle::kWhitespaceASCII;
@@ -41,7 +37,23 @@ namespace base
     using angle::SplitStringAlongWhitespace;
     using angle::HexStringToUInt;
     using angle::ReadFileToString;
-}
+
+    using TimeDelta = int;
+}  // namespace base
+
+namespace gfx
+{
+    class Size
+    {
+      public:
+        int width() const { return 0; }
+        int height() const { return 0; }
+    };
+}  // namespace gfx
+
+struct DxDiagNode
+{
+};
 
 // TODO(jmadill): other platforms
 // clang-format off

src/tests/third_party/gpu_test_expectations/gpu_info.cc

@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <stdint.h>
+
 #include "gpu_info.h"
 
 namespace {
@@ -17,10 +19,44 @@ void EnumerateGPUDevice(const gpu::GPUInfo::GPUDevice& device,
   enumerator->EndGPUDevice();
 }
 
+void EnumerateVideoDecodeAcceleratorSupportedProfile(
+    const gpu::VideoDecodeAcceleratorSupportedProfile& profile,
+    gpu::GPUInfo::Enumerator* enumerator) {
+  enumerator->BeginVideoDecodeAcceleratorSupportedProfile();
+  enumerator->AddInt("profile", profile.profile);
+  enumerator->AddInt("maxResolutionWidth", profile.max_resolution.width());
+  enumerator->AddInt("maxResolutionHeight", profile.max_resolution.height());
+  enumerator->AddInt("minResolutionWidth", profile.min_resolution.width());
+  enumerator->AddInt("minResolutionHeight", profile.min_resolution.height());
+  enumerator->AddBool("encrypted_only", profile.encrypted_only);
+  enumerator->EndVideoDecodeAcceleratorSupportedProfile();
+}
+
+void EnumerateVideoEncodeAcceleratorSupportedProfile(
+    const gpu::VideoEncodeAcceleratorSupportedProfile& profile,
+    gpu::GPUInfo::Enumerator* enumerator) {
+  enumerator->BeginVideoEncodeAcceleratorSupportedProfile();
+  enumerator->AddInt("profile", profile.profile);
+  enumerator->AddInt("maxResolutionWidth", profile.max_resolution.width());
+  enumerator->AddInt("maxResolutionHeight", profile.max_resolution.height());
+  enumerator->AddInt("maxFramerateNumerator", profile.max_framerate_numerator);
+  enumerator->AddInt("maxFramerateDenominator",
+                     profile.max_framerate_denominator);
+  enumerator->EndVideoEncodeAcceleratorSupportedProfile();
+}
+
 }  // namespace
 
 namespace gpu {
 
+VideoDecodeAcceleratorCapabilities::VideoDecodeAcceleratorCapabilities()
+    : flags(0) {}
+
+VideoDecodeAcceleratorCapabilities::VideoDecodeAcceleratorCapabilities(
+    const VideoDecodeAcceleratorCapabilities& other) = default;
+
+VideoDecodeAcceleratorCapabilities::~VideoDecodeAcceleratorCapabilities() {}
+
 GPUInfo::GPUDevice::GPUDevice()
     : vendor_id(0),
       device_id(0),
@@ -32,30 +68,49 @@ GPUInfo::GPUDevice::~GPUDevice() { }
 GPUInfo::GPUInfo()
     : optimus(false),
       amd_switchable(false),
-      lenovo_dcute(false),
-      adapter_luid(0),
       gl_reset_notification_strategy(0),
-      can_lose_context(false),
       software_rendering(false),
       direct_rendering(true),
       sandboxed(false),
       process_crash_count(0),
       in_process_gpu(true),
+      passthrough_cmd_decoder(false),
       basic_info_state(kCollectInfoNone),
       context_info_state(kCollectInfoNone),
-      jpeg_decode_accelerator_supported(false) {
+#if defined(OS_WIN)
+      dx_diagnostics_info_state(kCollectInfoNone),
+#endif
+      jpeg_decode_accelerator_supported(false)
+#if defined(USE_X11)
+      ,
+      system_visual(0),
+      rgba_visual(0)
+#endif
+{
 }
 
+GPUInfo::GPUInfo(const GPUInfo& other) = default;
+
 GPUInfo::~GPUInfo() { }
 
+const GPUInfo::GPUDevice& GPUInfo::active_gpu() const {
+  if (gpu.active)
+    return gpu;
+  for (const GPUDevice& secondary_gpu : secondary_gpus) {
+    if (secondary_gpu.active)
+      return secondary_gpu;
+  }
+  DLOG(ERROR) << "No active GPU found, returning primary GPU.\n";
+  return gpu;
+}
+
 void GPUInfo::EnumerateFields(Enumerator* enumerator) const {
   struct GPUInfoKnownFields {
+    base::TimeDelta initialization_time;
     bool optimus;
     bool amd_switchable;
-    bool lenovo_dcute;
     GPUDevice gpu;
     std::vector<GPUDevice> secondary_gpus;
-    uint64 adapter_luid;
     std::string driver_vendor;
     std::string driver_version;
     std::string driver_date;
@@ -71,16 +126,30 @@ void GPUInfo::EnumerateFields(Enumerator* enumerator) const {
     std::string gl_ws_vendor;
     std::string gl_ws_version;
     std::string gl_ws_extensions;
-    uint32 gl_reset_notification_strategy;
-    bool can_lose_context;
+    uint32_t gl_reset_notification_strategy;
     bool software_rendering;
     bool direct_rendering;
     bool sandboxed;
     int process_crash_count;
     bool in_process_gpu;
+    bool passthrough_cmd_decoder;
+    bool supports_overlays;
+    bool hdr;
+    bool can_support_threaded_texture_mailbox;
     CollectInfoResult basic_info_state;
     CollectInfoResult context_info_state;
+#if defined(OS_WIN)
+    CollectInfoResult dx_diagnostics_info_state;
+    DxDiagNode dx_diagnostics;
+#endif
+    VideoDecodeAcceleratorCapabilities video_decode_accelerator_capabilities;
+    VideoEncodeAcceleratorSupportedProfiles
+        video_encode_accelerator_supported_profiles;
     bool jpeg_decode_accelerator_supported;
+#if defined(USE_X11)
+    VisualID system_visual;
+    VisualID rgba_visual;
+#endif
   };
 
   // If this assert fails then most likely something below needs to be updated.
@@ -98,10 +167,10 @@ void GPUInfo::EnumerateFields(Enumerator* enumerator) const {
     EnumerateGPUDevice(secondary_gpu, enumerator);
 
   enumerator->BeginAuxAttributes();
+  enumerator->AddTimeDeltaInSecondsF("initializationTime",
+                                     initialization_time);
   enumerator->AddBool("optimus", optimus);
   enumerator->AddBool("amdSwitchable", amd_switchable);
-  enumerator->AddBool("lenovoDcute", lenovo_dcute);
-  enumerator->AddInt64("adapterLuid", adapter_luid);
   enumerator->AddString("driverVendor", driver_vendor);
   enumerator->AddString("driverVersion", driver_version);
   enumerator->AddString("driverDate", driver_date);
@@ -118,18 +187,36 @@ void GPUInfo::EnumerateFields(Enumerator* enumerator) const {
   enumerator->AddInt(
       "glResetNotificationStrategy",
       static_cast<int>(gl_reset_notification_strategy));
-  enumerator->AddBool("can_lose_context", can_lose_context);
   // TODO(kbr): add performance_stats.
   enumerator->AddBool("softwareRendering", software_rendering);
   enumerator->AddBool("directRendering", direct_rendering);
   enumerator->AddBool("sandboxed", sandboxed);
   enumerator->AddInt("processCrashCount", process_crash_count);
   enumerator->AddBool("inProcessGpu", in_process_gpu);
+  enumerator->AddBool("passthroughCmdDecoder", passthrough_cmd_decoder);
+  enumerator->AddBool("supportsOverlays", supports_overlays);
+  enumerator->AddBool("hdr", hdr);
+  enumerator->AddBool("canSupportThreadedTextureMailbox",
+                      can_support_threaded_texture_mailbox);
   enumerator->AddInt("basicInfoState", basic_info_state);
   enumerator->AddInt("contextInfoState", context_info_state);
+#if defined(OS_WIN)
+  enumerator->AddInt("DxDiagnosticsInfoState", dx_diagnostics_info_state);
+#endif
   // TODO(kbr): add dx_diagnostics on Windows.
+  enumerator->AddInt("videoDecodeAcceleratorFlags",
+                     video_decode_accelerator_capabilities.flags);
+  for (const auto& profile :
+       video_decode_accelerator_capabilities.supported_profiles)
+    EnumerateVideoDecodeAcceleratorSupportedProfile(profile, enumerator);
+  for (const auto& profile : video_encode_accelerator_supported_profiles)
+    EnumerateVideoEncodeAcceleratorSupportedProfile(profile, enumerator);
   enumerator->AddBool("jpegDecodeAcceleratorSupported",
       jpeg_decode_accelerator_supported);
+#if defined(USE_X11)
+  enumerator->AddInt64("systemVisual", system_visual);
+  enumerator->AddInt64("rgbaVisual", rgba_visual);
+#endif
   enumerator->EndAuxAttributes();
 }
 

src/tests/third_party/gpu_test_expectations/gpu_info.h

@@ -2,17 +2,23 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef GPU_CONFIG_GPU_INFO_H_
-#define GPU_CONFIG_GPU_INFO_H_
+#ifndef ANGLE_GPU_CONFIG_GPU_INFO_H_
+#define ANGLE_GPU_CONFIG_GPU_INFO_H_
 
 // Provides access to the GPU information for the system
 // on which chrome is currently running.
 
+#include <stdint.h>
+
 #include <string>
 #include <vector>
 
 #include "angle_config.h"
 
+#if defined(USE_X11)
+typedef unsigned long VisualID;
+#endif
+
 namespace gpu {
 
 // Result for the various Collect*Info* functions below.
@@ -33,32 +39,72 @@ enum VideoCodecProfile {
   VIDEO_CODEC_PROFILE_UNKNOWN = -1,
   VIDEO_CODEC_PROFILE_MIN = VIDEO_CODEC_PROFILE_UNKNOWN,
   H264PROFILE_BASELINE = 0,
-  H264PROFILE_MAIN = 1,
-  H264PROFILE_EXTENDED = 2,
-  H264PROFILE_HIGH = 3,
-  H264PROFILE_HIGH10PROFILE = 4,
-  H264PROFILE_HIGH422PROFILE = 5,
-  H264PROFILE_HIGH444PREDICTIVEPROFILE = 6,
-  H264PROFILE_SCALABLEBASELINE = 7,
-  H264PROFILE_SCALABLEHIGH = 8,
-  H264PROFILE_STEREOHIGH = 9,
-  H264PROFILE_MULTIVIEWHIGH = 10,
-  VP8PROFILE_ANY = 11,
-  VP9PROFILE_ANY = 12,
-  VIDEO_CODEC_PROFILE_MAX = VP9PROFILE_ANY,
+  H264PROFILE_MAIN,
+  H264PROFILE_EXTENDED,
+  H264PROFILE_HIGH,
+  H264PROFILE_HIGH10PROFILE,
+  H264PROFILE_HIGH422PROFILE,
+  H264PROFILE_HIGH444PREDICTIVEPROFILE,
+  H264PROFILE_SCALABLEBASELINE,
+  H264PROFILE_SCALABLEHIGH,
+  H264PROFILE_STEREOHIGH,
+  H264PROFILE_MULTIVIEWHIGH,
+  VP8PROFILE_ANY,
+  VP9PROFILE_PROFILE0,
+  VP9PROFILE_PROFILE1,
+  VP9PROFILE_PROFILE2,
+  VP9PROFILE_PROFILE3,
+  HEVCPROFILE_MAIN,
+  HEVCPROFILE_MAIN10,
+  HEVCPROFILE_MAIN_STILL_PICTURE,
+  DOLBYVISION_PROFILE0,
+  DOLBYVISION_PROFILE4,
+  DOLBYVISION_PROFILE5,
+  DOLBYVISION_PROFILE7,
+  VIDEO_CODEC_PROFILE_MAX = DOLBYVISION_PROFILE7,
+};
+
+// Specification of a decoding profile supported by a hardware decoder.
+struct GPU_EXPORT VideoDecodeAcceleratorSupportedProfile {
+  VideoCodecProfile profile;
+  gfx::Size max_resolution;
+  gfx::Size min_resolution;
+  bool encrypted_only;
+};
+
+using VideoDecodeAcceleratorSupportedProfiles =
+    std::vector<VideoDecodeAcceleratorSupportedProfile>;
+
+struct GPU_EXPORT VideoDecodeAcceleratorCapabilities {
+  VideoDecodeAcceleratorCapabilities();
+  VideoDecodeAcceleratorCapabilities(
+      const VideoDecodeAcceleratorCapabilities& other);
+  ~VideoDecodeAcceleratorCapabilities();
+  VideoDecodeAcceleratorSupportedProfiles supported_profiles;
+  uint32_t flags;
+};
+
+// Specification of an encoding profile supported by a hardware encoder.
+struct GPU_EXPORT VideoEncodeAcceleratorSupportedProfile {
+  VideoCodecProfile profile;
+  gfx::Size max_resolution;
+  uint32_t max_framerate_numerator;
+  uint32_t max_framerate_denominator;
 };
+using VideoEncodeAcceleratorSupportedProfiles =
+    std::vector<VideoEncodeAcceleratorSupportedProfile>;
 
 struct GPU_EXPORT GPUInfo {
   struct GPU_EXPORT GPUDevice {
     GPUDevice();
     ~GPUDevice();
 
-    // The DWORD (uint32) representing the graphics card vendor id.
-    uint32 vendor_id;
+    // The DWORD (uint32_t) representing the graphics card vendor id.
+    uint32_t vendor_id;
 
-    // The DWORD (uint32) representing the graphics card device id.
+    // The DWORD (uint32_t) representing the graphics card device id.
     // Device ids are unique to vendor, not to one another.
-    uint32 device_id;
+    uint32_t device_id;
 
     // Whether this GPU is the currently used one.
     // Currently this field is only supported and meaningful on OS X.
@@ -73,11 +119,12 @@ struct GPU_EXPORT GPUInfo {
   };
 
   GPUInfo();
+  GPUInfo(const GPUInfo& other);
   ~GPUInfo();
 
-  bool SupportsAccelerated2dCanvas() const {
-    return !can_lose_context && !software_rendering;
-  }
+  // The amount of time taken to get from the process starting to the message
+  // loop being pumped.
+  base::TimeDelta initialization_time;
 
   // Computer has NVIDIA Optimus
   bool optimus;
@@ -85,21 +132,14 @@ struct GPU_EXPORT GPUInfo {
   // Computer has AMD Dynamic Switchable Graphics
   bool amd_switchable;
 
-  // Lenovo dCute is installed. http://crbug.com/181665.
-  bool lenovo_dcute;
-
   // Primary GPU, for exmaple, the discrete GPU in a dual GPU machine.
   GPUDevice gpu;
 
   // Secondary GPUs, for example, the integrated GPU in a dual GPU machine.
   std::vector<GPUDevice> secondary_gpus;
 
-  // On Windows, the unique identifier of the adapter the GPU process uses.
-  // The default is zero, which makes the browser process create its D3D device
-  // on the primary adapter. Note that the primary adapter can change at any
-  // time so it is better to specify a particular LUID. Note that valid LUIDs
-  // are always non-zero.
-  uint64 adapter_luid;
+  // The currently active gpu.
+  const GPUDevice& active_gpu() const;
 
   // The vendor of the graphics driver currently installed.
   std::string driver_vendor;
@@ -155,11 +195,7 @@ struct GPU_EXPORT GPUInfo {
 
   // GL reset notification strategy as defined by GL_ARB_robustness. 0 if GPU
   // reset detection or notification not available.
-  uint32 gl_reset_notification_strategy;
-
-  // The device semantics, i.e. whether the Vista and Windows 7 specific
-  // semantics are available.
-  bool can_lose_context;
+  uint32_t gl_reset_notification_strategy;
 
   bool software_rendering;
 
@@ -176,13 +212,41 @@ struct GPU_EXPORT GPUInfo {
   // True if the GPU is running in the browser process instead of its own.
   bool in_process_gpu;
 
+  // True if the GPU process is using the passthrough command decoder.
+  bool passthrough_cmd_decoder;
+
+  // True if the current set of outputs supports overlays.
+  bool supports_overlays = false;
+
+  // True if the current set of outputs supports HDR.
+  bool hdr = false;
+
+  // True only on android when extensions for threaded mailbox sharing are
+  // present. Threaded mailbox sharing is used on Android only, so this check
+  // is only implemented on Android.
+  bool can_support_threaded_texture_mailbox = false;
+
   // The state of whether the basic/context/DxDiagnostics info is collected and
   // if the collection fails or not.
   CollectInfoResult basic_info_state;
   CollectInfoResult context_info_state;
+#if defined(OS_WIN)
+  CollectInfoResult dx_diagnostics_info_state;
 
+  // The information returned by the DirectX Diagnostics Tool.
+  DxDiagNode dx_diagnostics;
+#endif
+
+  VideoDecodeAcceleratorCapabilities video_decode_accelerator_capabilities;
+  VideoEncodeAcceleratorSupportedProfiles
+      video_encode_accelerator_supported_profiles;
   bool jpeg_decode_accelerator_supported;
 
+#if defined(USE_X11)
+  VisualID system_visual;
+  VisualID rgba_visual;
+#endif
+
   // Note: when adding new members, please remember to update EnumerateFields
   // in gpu_info.cc.
 
@@ -196,10 +260,12 @@ struct GPU_EXPORT GPUInfo {
     // is the root object, but calls to BeginGPUDevice/EndGPUDevice and
     // BeginAuxAttributes/EndAuxAttributes change the object to which these
     // calls should apply.
-    virtual void AddInt64(const char* name, int64 value) = 0;
+    virtual void AddInt64(const char* name, int64_t value) = 0;
     virtual void AddInt(const char* name, int value) = 0;
     virtual void AddString(const char* name, const std::string& value) = 0;
     virtual void AddBool(const char* name, bool value) = 0;
+    virtual void AddTimeDeltaInSecondsF(const char* name,
+                                        const base::TimeDelta& value) = 0;
 
     // Markers indicating that a GPUDevice is being described.
     virtual void BeginGPUDevice() = 0;
@@ -230,4 +296,4 @@ struct GPU_EXPORT GPUInfo {
 
 }  // namespace gpu
 
-#endif  // GPU_CONFIG_GPU_INFO_H_
+#endif  // ANGLE_GPU_CONFIG_GPU_INFO_H_

src/tests/third_party/gpu_test_expectations/gpu_test_config.cc

@@ -4,25 +4,23 @@
 
 #include "gpu_test_config.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "gpu_info.h"
 #include "gpu_test_expectations_parser.h"
 
-#if defined(OS_LINUX)
-extern "C" {
-#   include <pci/pci.h>
-}
-#endif
-
 #if defined(OS_MACOSX)
 #include "gpu_test_config_mac.h"
 #endif
 
-using namespace gpu;
+#if !defined(OS_ANDROID)
+#include "gpu_info_util/SystemInfo.h"
+#endif
 
 #if defined(OS_WIN)
 
 namespace base {
-
 namespace {
 
 // Disable the deprecated function warning for GetVersionEx
@@ -32,12 +30,12 @@ class SysInfo
 {
   public:
     static void OperatingSystemVersionNumbers(
-        int32 *major_version, int32 *minor_version, int32 *bugfix_version);
+        int32_t *major_version, int32_t *minor_version, int32_t *bugfix_version);
 };
 
 // static
 void SysInfo::OperatingSystemVersionNumbers(
-    int32 *major_version, int32 *minor_version, int32 *bugfix_version)
+    int32_t *major_version, int32_t *minor_version, int32_t *bugfix_version)
 {
   OSVERSIONINFOEX version_info = { sizeof version_info };
   ::GetVersionEx(reinterpret_cast<OSVERSIONINFO*>(&version_info));
@@ -47,160 +45,10 @@ void SysInfo::OperatingSystemVersionNumbers(
 }
 
 } // anonymous namespace
-
 } // namespace base
 
-void DeviceIDToVendorAndDevice(const std::string& id,
-                               uint32* vendor_id,
-                               uint32* device_id) {
-  *vendor_id = 0;
-  *device_id = 0;
-  if (id.length() < 21)
-    return;
-  std::string vendor_id_string = id.substr(8, 4);
-  std::string device_id_string = id.substr(17, 4);
-  base::HexStringToUInt(vendor_id_string, vendor_id);
-  base::HexStringToUInt(device_id_string, device_id);
-}
-
-CollectInfoResult CollectGpuID(uint32* vendor_id, uint32* device_id) {
-  DCHECK(vendor_id && device_id);
-  *vendor_id = 0;
-  *device_id = 0;
-
-  // Taken from http://developer.nvidia.com/object/device_ids.html
-  DISPLAY_DEVICEA dd;
-  dd.cb = sizeof(DISPLAY_DEVICEA);
-  std::string id;
-  for (int i = 0; EnumDisplayDevicesA(NULL, i, &dd, 0); ++i) {
-    if (dd.StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE) {
-      id = dd.DeviceID;
-      break;
-    }
-  }
-
-  if (id.length() > 20) {
-    DeviceIDToVendorAndDevice(id, vendor_id, device_id);
-    if (*vendor_id != 0 && *device_id != 0)
-      return kCollectInfoSuccess;
-  }
-  return kCollectInfoNonFatalFailure;
-}
-
 #endif // defined(OS_WIN)
 
-#if defined(OS_LINUX)
-
-const uint32 kVendorIDIntel = 0x8086;
-const uint32 kVendorIDNVidia = 0x10de;
-const uint32 kVendorIDAMD = 0x1002;
-
-CollectInfoResult CollectPCIVideoCardInfo(GPUInfo* gpu_info) {
-  DCHECK(gpu_info);
-
-  struct pci_access* access = pci_alloc();
-  DCHECK(access != NULL);
-  pci_init(access);
-  pci_scan_bus(access);
-
-  bool primary_gpu_identified = false;
-  for (pci_dev* device = access->devices;
-       device != NULL; device = device->next) {
-    pci_fill_info(device, 33);
-    bool is_gpu = false;
-    switch (device->device_class) {
-      case PCI_CLASS_DISPLAY_VGA:
-      case PCI_CLASS_DISPLAY_XGA:
-      case PCI_CLASS_DISPLAY_3D:
-        is_gpu = true;
-        break;
-      case PCI_CLASS_DISPLAY_OTHER:
-      default:
-        break;
-    }
-    if (!is_gpu)
-      continue;
-    if (device->vendor_id == 0 || device->device_id == 0)
-      continue;
-
-    GPUInfo::GPUDevice gpu;
-    gpu.vendor_id = device->vendor_id;
-    gpu.device_id = device->device_id;
-
-    if (!primary_gpu_identified) {
-      primary_gpu_identified = true;
-      gpu_info->gpu = gpu;
-    } else {
-      // TODO(zmo): if there are multiple GPUs, we assume the non Intel
-      // one is primary. Revisit this logic because we actually don't know
-      // which GPU we are using at this point.
-      if (gpu_info->gpu.vendor_id == kVendorIDIntel &&
-          gpu.vendor_id != kVendorIDIntel) {
-        gpu_info->secondary_gpus.push_back(gpu_info->gpu);
-        gpu_info->gpu = gpu;
-      } else {
-        gpu_info->secondary_gpus.push_back(gpu);
-      }
-    }
-  }
-
-  // Detect Optimus or AMD Switchable GPU.
-  if (gpu_info->secondary_gpus.size() == 1 &&
-      gpu_info->secondary_gpus[0].vendor_id == kVendorIDIntel) {
-    if (gpu_info->gpu.vendor_id == kVendorIDNVidia)
-      gpu_info->optimus = true;
-    if (gpu_info->gpu.vendor_id == kVendorIDAMD)
-      gpu_info->amd_switchable = true;
-  }
-
-  pci_cleanup(access);
-  if (!primary_gpu_identified)
-    return kCollectInfoNonFatalFailure;
-  return kCollectInfoSuccess;
-}
-
-CollectInfoResult CollectGpuID(uint32* vendor_id, uint32* device_id) {
-  DCHECK(vendor_id && device_id);
-  *vendor_id = 0;
-  *device_id = 0;
-
-  GPUInfo gpu_info;
-  CollectInfoResult result = CollectPCIVideoCardInfo(&gpu_info);
-  if (result == kCollectInfoSuccess) {
-    *vendor_id = gpu_info.gpu.vendor_id;
-    *device_id = gpu_info.gpu.device_id;
-  }
-  return result;
-}
-
-#endif // defined(OS_LINUX)
-
-#if defined(OS_MACOSX)
-
-CollectInfoResult CollectGpuID(uint32* vendor_id, uint32* device_id) {
-  DCHECK(vendor_id && device_id);
-
-  GPUInfo::GPUDevice gpu = GetActiveGPU();
-  *vendor_id = gpu.vendor_id;
-  *device_id = gpu.device_id;
-
-  if (*vendor_id != 0 && *device_id != 0)
-    return kCollectInfoSuccess;
-  return kCollectInfoNonFatalFailure;
-}
-
-#endif
-
-#if defined(OS_ANDROID)
-CollectInfoResult CollectGpuID(uint32 *vendor_id, uint32 *device_id)
-{
-    DCHECK(vendor_id && device_id);
-    *vendor_id = 0;
-    *device_id = 0;
-    return kCollectInfoNonFatalFailure;
-}
-#endif  // defined(OS_ANDROID)
-
 namespace gpu {
 
 namespace {
@@ -211,9 +59,9 @@ GPUTestConfig::OS GetCurrentOS() {
 #elif defined(OS_LINUX) || defined(OS_OPENBSD)
   return GPUTestConfig::kOsLinux;
 #elif defined(OS_WIN)
-  int32 major_version = 0;
-  int32 minor_version = 0;
-  int32 bugfix_version = 0;
+  int32_t major_version = 0;
+  int32_t minor_version = 0;
+  int32_t bugfix_version = 0;
   base::SysInfo::OperatingSystemVersionNumbers(
       &major_version, &minor_version, &bugfix_version);
   if (major_version == 5)
@@ -227,9 +75,9 @@ GPUTestConfig::OS GetCurrentOS() {
   if (major_version == 10)
     return GPUTestConfig::kOsWin10;
 #elif defined(OS_MACOSX)
-  int32 major_version = 0;
-  int32 minor_version = 0;
-  int32 bugfix_version = 0;
+  int32_t major_version = 0;
+  int32_t minor_version = 0;
+  int32_t bugfix_version = 0;
   base::SysInfo::OperatingSystemVersionNumbers(
       &major_version, &minor_version, &bugfix_version);
   if (major_version == 10) {
@@ -248,6 +96,8 @@ GPUTestConfig::OS GetCurrentOS() {
         return GPUTestConfig::kOsMacYosemite;
       case 11:
         return GPUTestConfig::kOsMacElCapitan;
+      case 12:
+        return GPUTestConfig::kOsMacSierra;
     }
   }
 #elif defined(OS_ANDROID)
@@ -256,6 +106,26 @@ GPUTestConfig::OS GetCurrentOS() {
   return GPUTestConfig::kOsUnknown;
 }
 
+#if !defined(OS_ANDROID)
+CollectInfoResult CollectBasicGraphicsInfo(GPUInfo* gpu_info) {
+  angle::SystemInfo info;
+  if (!angle::GetSystemInfo(&info)) {
+    return kCollectInfoFatalFailure;
+  }
+  const angle::GPUDeviceInfo& gpu = info.gpus[info.primaryGPUIndex];
+  gpu_info->gpu.vendor_id = gpu.vendorId;
+  gpu_info->gpu.device_id = gpu.deviceId;
+  gpu_info->gpu.active = true;
+  return kCollectInfoSuccess;
+}
+#else
+CollectInfoResult CollectBasicGraphicsInfo(GPUInfo* gpu_info) {
+  gpu_info->gpu.vendor_id = 0;
+  gpu_info->gpu.device_id = 0;
+  gpu_info->gpu.active = true;
+  return kCollectInfoNonFatalFailure;
+}
+#endif  // defined(OS_ANDROID)
 }  // namespace anonymous
 
 GPUTestConfig::GPUTestConfig()
@@ -265,31 +135,33 @@ GPUTestConfig::GPUTestConfig()
       build_type_(kBuildTypeUnknown),
       api_(kAPIUnknown) {}
 
+GPUTestConfig::GPUTestConfig(const GPUTestConfig& other) = default;
+
 GPUTestConfig::~GPUTestConfig() {
 }
 
-void GPUTestConfig::set_os(int32 os) {
+void GPUTestConfig::set_os(int32_t os) {
   DCHECK_EQ(0, os & ~(kOsAndroid | kOsWin | kOsMac | kOsLinux | kOsChromeOS));
   os_ = os;
 }
 
-void GPUTestConfig::AddGPUVendor(uint32 gpu_vendor) {
+void GPUTestConfig::AddGPUVendor(uint32_t gpu_vendor) {
   DCHECK_NE(0u, gpu_vendor);
   for (size_t i = 0; i < gpu_vendor_.size(); ++i)
     DCHECK_NE(gpu_vendor_[i], gpu_vendor);
   gpu_vendor_.push_back(gpu_vendor);
 }
 
-void GPUTestConfig::set_gpu_device_id(uint32 id) {
+void GPUTestConfig::set_gpu_device_id(uint32_t id) {
   gpu_device_id_ = id;
 }
 
-void GPUTestConfig::set_build_type(int32 build_type) {
+void GPUTestConfig::set_build_type(int32_t build_type) {
   DCHECK_EQ(0, build_type & ~(kBuildTypeRelease | kBuildTypeDebug));
   build_type_ = build_type;
 }
 
-void GPUTestConfig::set_api(int32 api) {
+void GPUTestConfig::set_api(int32_t api) {
   DCHECK_EQ(0, api & ~(kAPID3D9 | kAPID3D11 | kAPIGLDesktop | kAPIGLES));
   api_ = api;
 }
@@ -342,7 +214,7 @@ void GPUTestConfig::ClearGPUVendor() {
 GPUTestBotConfig::~GPUTestBotConfig() {
 }
 
-void GPUTestBotConfig::AddGPUVendor(uint32 gpu_vendor) {
+void GPUTestBotConfig::AddGPUVendor(uint32_t gpu_vendor) {
   DCHECK_EQ(0u, GPUTestConfig::gpu_vendor().size());
   GPUTestConfig::AddGPUVendor(gpu_vendor);
 }
@@ -371,6 +243,7 @@ bool GPUTestBotConfig::IsValid() const {
     case kOsMacMavericks:
     case kOsMacYosemite:
     case kOsMacElCapitan:
+    case kOsMacSierra:
     case kOsLinux:
     case kOsChromeOS:
     case kOsAndroid:
@@ -430,41 +303,32 @@ bool GPUTestBotConfig::Matches(const std::string& config_data) const {
   return Matches(config);
 }
 
-bool GPUTestBotConfig::LoadCurrentConfig(const GPUInfo *gpu_info)
-{
-    bool rt;
-    if (gpu_info == NULL)
-    {
-        GPUInfo my_gpu_info;
-        CollectInfoResult result =
-            CollectGpuID(&my_gpu_info.gpu.vendor_id, &my_gpu_info.gpu.device_id);
-        if (result != kCollectInfoSuccess)
-        {
-            LOG(ERROR) << "Fail to identify GPU\n";
-            DisableGPUInfoValidation();
-            rt = true;
-        }
-        else
-        {
-            rt = SetGPUInfo(my_gpu_info);
-        }
-    }
-    else
-    {
-        rt = SetGPUInfo(*gpu_info);
-    }
-    set_os(GetCurrentOS());
-    if (os() == kOsUnknown)
-    {
-        LOG(ERROR) << "Unknown OS\n";
-        rt = false;
+bool GPUTestBotConfig::LoadCurrentConfig(const GPUInfo* gpu_info) {
+  bool rt;
+  if (gpu_info == NULL) {
+    GPUInfo my_gpu_info;
+    CollectInfoResult result = CollectBasicGraphicsInfo(&my_gpu_info);
+    if (result != kCollectInfoSuccess) {
+      LOG(ERROR) << "Fail to identify GPU\n";
+      DisableGPUInfoValidation();
+      rt = true;
+    } else {
+      rt = SetGPUInfo(my_gpu_info);
     }
+  } else {
+    rt = SetGPUInfo(*gpu_info);
+  }
+  set_os(GetCurrentOS());
+  if (os() == kOsUnknown) {
+    LOG(ERROR) << "Unknown OS\n";
+    rt = false;
+  }
 #if defined(NDEBUG)
-    set_build_type(kBuildTypeRelease);
+  set_build_type(kBuildTypeRelease);
 #else
-    set_build_type(kBuildTypeDebug);
+  set_build_type(kBuildTypeDebug);
 #endif
-    return rt;
+  return rt;
 }
 
 // static
@@ -488,5 +352,10 @@ bool GPUTestBotConfig::CurrentConfigMatches(
   return false;
 }
 
+// static
+bool GPUTestBotConfig::GpuBlacklistedOnBot() {
+  return false;
+}
+
 }  // namespace gpu
 

src/tests/third_party/gpu_test_expectations/gpu_test_config.h

@@ -2,8 +2,10 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef GPU_CONFIG_GPU_TEST_CONFIG_H_
-#define GPU_CONFIG_GPU_TEST_CONFIG_H_
+#ifndef ANGLE_GPU_CONFIG_GPU_TEST_CONFIG_H_
+#define ANGLE_GPU_CONFIG_GPU_TEST_CONFIG_H_
+
+#include <stdint.h>
 
 #include <string>
 #include <vector>
@@ -29,13 +31,14 @@ class GPU_EXPORT GPUTestConfig {
     kOsMacMavericks = 1 << 8,
     kOsMacYosemite = 1 << 9,
     kOsMacElCapitan = 1 << 10,
+    kOsMacSierra = 1 << 11,
     kOsMac = kOsMacLeopard | kOsMacSnowLeopard | kOsMacLion |
              kOsMacMountainLion | kOsMacMavericks | kOsMacYosemite |
-             kOsMacElCapitan,
-    kOsLinux = 1 << 11,
-    kOsChromeOS = 1 << 12,
-    kOsAndroid = 1 << 13,
-    kOsWin10 = 1 << 14,
+             kOsMacElCapitan | kOsMacSierra,
+    kOsLinux = 1 << 12,
+    kOsChromeOS = 1 << 13,
+    kOsAndroid = 1 << 14,
+    kOsWin10 = 1 << 15,
     kOsWin = kOsWinXP | kOsWinVista | kOsWin7 | kOsWin8 | kOsWin10,
   };
 
@@ -54,20 +57,21 @@ class GPU_EXPORT GPUTestConfig {
   };
 
   GPUTestConfig();
+  GPUTestConfig(const GPUTestConfig& other);
   virtual ~GPUTestConfig();
 
-  void set_os(int32 os);
-  void set_gpu_device_id(uint32 id);
-  void set_build_type(int32 build_type);
-  void set_api(int32 api);
+  void set_os(int32_t os);
+  void set_gpu_device_id(uint32_t id);
+  void set_build_type(int32_t build_type);
+  void set_api(int32_t api);
 
-  virtual void AddGPUVendor(uint32 gpu_vendor);
+  virtual void AddGPUVendor(uint32_t gpu_vendor);
 
-  int32 os() const { return os_; }
-  const std::vector<uint32>& gpu_vendor() const { return gpu_vendor_; }
-  uint32 gpu_device_id() const { return gpu_device_id_; }
-  int32 build_type() const { return build_type_; }
-  int32 api() const { return api_; }
+  int32_t os() const { return os_; }
+  const std::vector<uint32_t>& gpu_vendor() const { return gpu_vendor_; }
+  uint32_t gpu_device_id() const { return gpu_device_id_; }
+  int32_t build_type() const { return build_type_; }
+  int32_t api() const { return api_; }
 
   // Check if the config is valid. For example, if gpu_device_id_ is set, but
   // gpu_vendor_ is unknown, then it's invalid.
@@ -89,19 +93,19 @@ class GPU_EXPORT GPUTestConfig {
 
  private:
   // operating system.
-  int32 os_;
+  int32_t os_;
 
   // GPU vendor.
-  std::vector<uint32> gpu_vendor_;
+  std::vector<uint32_t> gpu_vendor_;
 
   // GPU device id (unique to each vendor).
-  uint32 gpu_device_id_;
+  uint32_t gpu_device_id_;
 
   // Release or Debug.
-  int32 build_type_;
+  int32_t build_type_;
 
   // Back-end rendering APIs.
-  int32 api_;
+  int32_t api_;
 };
 
 class GPU_EXPORT GPUTestBotConfig : public GPUTestConfig {
@@ -110,7 +114,7 @@ class GPU_EXPORT GPUTestBotConfig : public GPUTestConfig {
   ~GPUTestBotConfig() override;
 
   // This should only be called when no gpu_vendor is added.
-  void AddGPUVendor(uint32 gpu_vendor) override;
+  void AddGPUVendor(uint32_t gpu_vendor) override;
 
   // Return false if gpu_info does not have valid vendor_id and device_id.
   bool SetGPUInfo(const GPUInfo& gpu_info);
@@ -132,9 +136,12 @@ class GPU_EXPORT GPUTestBotConfig : public GPUTestConfig {
   // Check if this bot's config matches |config_data| or any of the |configs|.
   static bool CurrentConfigMatches(const std::string& config_data);
   static bool CurrentConfigMatches(const std::vector<std::string>& configs);
+
+  // Check if the bot has blacklisted all GPU features.
+  static bool GpuBlacklistedOnBot();
 };
 
 }  // namespace gpu
 
-#endif  // GPU_CONFIG_GPU_TEST_CONFIG_H_
+#endif  // ANGLE_GPU_CONFIG_GPU_TEST_CONFIG_H_
 

src/tests/third_party/gpu_test_expectations/gpu_test_config_mac.h

@@ -7,8 +7,8 @@
 //   Helper functions for gpu_test_config that have to be compiled in ObjectiveC++
 //
 
-#ifndef GPU_TEST_EXPECTATIONS_GPU_TEST_CONFIG_MAC_H_
-#define GPU_TEST_EXPECTATIONS_GPU_TEST_CONFIG_MAC_H_
+#ifndef ANGLE_GPU_TEST_EXPECTATIONS_GPU_TEST_CONFIG_MAC_H_
+#define ANGLE_GPU_TEST_EXPECTATIONS_GPU_TEST_CONFIG_MAC_H_
 
 #include "gpu_info.h"
 
@@ -17,12 +17,11 @@ namespace base {
 class SysInfo
 {
   public:
-    static void OperatingSystemVersionNumbers(
-        int32 *major_version, int32 *minor_version, int32 *bugfix_version);
+    static void OperatingSystemVersionNumbers(int32_t *major_version,
+                                              int32_t *minor_version,
+                                              int32_t *bugfix_version);
 };
 
 } // namespace base
 
-gpu::GPUInfo::GPUDevice GetActiveGPU();
-
-#endif // GPU_TEST_EXPECTATIONS_GPU_TEST_CONFIG_MAC_H_
+#endif // ANGLE_GPU_TEST_EXPECTATIONS_GPU_TEST_CONFIG_MAC_H_

src/tests/third_party/gpu_test_expectations/gpu_test_config_mac.mm

@@ -19,8 +19,9 @@ namespace base {
 @end
 #endif
 
-void SysInfo::OperatingSystemVersionNumbers(
-    int32 *major_version, int32 *minor_version, int32 *bugfix_version)
+void SysInfo::OperatingSystemVersionNumbers(int32_t *major_version,
+                                            int32_t *minor_version,
+                                            int32_t *bugfix_version)
 {
 #if MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_8
   Gestalt(gestaltSystemVersionMajor, reinterpret_cast<SInt32*>(major_version));
@@ -35,41 +36,3 @@ void SysInfo::OperatingSystemVersionNumbers(
 }
 
 } // namespace base
-
-UInt32 GetEntryProperty(io_registry_entry_t entry, CFStringRef property_name) {
-  CFTypeRef type = IORegistryEntrySearchCFProperty(entry,
-                                                   kIOServicePlane,
-                                                   property_name,
-                                                   kCFAllocatorDefault,
-                                                   kIORegistryIterateRecursively | kIORegistryIterateParents);
-  CFDataRef data = reinterpret_cast<CFDataRef>(type);
-  if (!data) {
-    CFRelease(data);
-    return 0;
-  }
-
-  UInt32 value = 0;
-  const uint32_t* valuePointer = reinterpret_cast<const uint32_t*>(CFDataGetBytePtr(data));
-  if (valuePointer != NULL) {
-    value = *valuePointer;
-  }
-  CFRelease(data);
-  return value;
-}
-
-gpu::GPUInfo::GPUDevice GetActiveGPU() {
-  gpu::GPUInfo::GPUDevice gpu;
-
-  // Ignore the fact that CGDisplayIOServicePort is deprecated as Apple
-  // did not provide a good replacement for it as of 10.10.
-  // TODO(cwallez) revisit with later systems
-  #pragma clang diagnostic push
-  #pragma clang diagnostic ignored "-Wdeprecated-declarations"
-    io_registry_entry_t dsp_port = CGDisplayIOServicePort(kCGDirectMainDisplay);
-  #pragma clang diagnostic pop
-
-  gpu.vendor_id = GetEntryProperty(dsp_port, CFSTR("vendor-id"));
-  gpu.device_id = GetEntryProperty(dsp_port, CFSTR("device-id"));
-  return gpu;
-}
-

src/tests/third_party/gpu_test_expectations/gpu_test_expectations_parser.cc

@@ -4,8 +4,10 @@
 
 #include "gpu_test_expectations_parser.h"
 
-#include <sstream>
+#include <stddef.h>
+#include <stdint.h>
 
+#include "angle_config.h"
 #include "common/angleutils.h"
 
 namespace base {
@@ -71,6 +73,7 @@ enum Token {
   kConfigMacMavericks,
   kConfigMacYosemite,
   kConfigMacElCapitan,
+  kConfigMacSierra,
   kConfigMac,
   kConfigLinux,
   kConfigChromeOS,
@@ -108,7 +111,7 @@ enum Token {
 
 struct TokenInfo {
   const char* name;
-  int32 flag;
+  int32_t flag;
 };
 
 const TokenInfo kTokenData[] = {
@@ -125,6 +128,7 @@ const TokenInfo kTokenData[] = {
     {"mavericks", GPUTestConfig::kOsMacMavericks},
     {"yosemite", GPUTestConfig::kOsMacYosemite},
     {"elcapitan", GPUTestConfig::kOsMacElCapitan},
+    {"sierra", GPUTestConfig::kOsMacSierra},
     {"mac", GPUTestConfig::kOsMac},
     {"linux", GPUTestConfig::kOsLinux},
     {"chromeos", GPUTestConfig::kOsChromeOS},
@@ -182,7 +186,7 @@ Token ParseToken(const std::string& word) {
   if (base::StartsWithASCII(word, "0x", false))
     return kConfigGPUDeviceID;
 
-  for (int32 i = 0; i < kNumberOfExactMatchTokens; ++i) {
+  for (int32_t i = 0; i < kNumberOfExactMatchTokens; ++i) {
     if (base::LowerCaseEqualsASCII(word, kTokenData[i].name))
       return static_cast<Token>(i);
   }
@@ -207,10 +211,10 @@ bool NamesMatching(const std::string& ref, const std::string& test_name) {
 
 GPUTestExpectationsParser::GPUTestExpectationsParser() {
   // Some sanity check.
-  static_assert(static_cast<unsigned int>(kNumberOfExactMatchTokens) ==
-                sizeof(kTokenData) / sizeof(kTokenData[0]), "sanity check");
-  static_assert(static_cast<unsigned int>(kNumberOfErrors) ==
-                sizeof(kErrorMessage) / sizeof(kErrorMessage[0]), "sanity check");
+  DCHECK_EQ(static_cast<unsigned int>(kNumberOfExactMatchTokens),
+            sizeof(kTokenData) / sizeof(kTokenData[0]));
+  DCHECK_EQ(static_cast<unsigned int>(kNumberOfErrors),
+            sizeof(kErrorMessage) / sizeof(kErrorMessage[0]));
 }
 
 GPUTestExpectationsParser::~GPUTestExpectationsParser() {
@@ -248,7 +252,7 @@ bool GPUTestExpectationsParser::LoadTestExpectationsFromFile(
   return LoadTestExpectations(data);
 }
 
-int32 GPUTestExpectationsParser::GetTestExpectation(
+int32_t GPUTestExpectationsParser::GetTestExpectation(
     const std::string& test_name,
     const GPUTestBotConfig& bot_config) const {
   for (size_t i = 0; i < entries_.size(); ++i) {
@@ -287,6 +291,7 @@ bool GPUTestExpectationsParser::ParseConfig(
       case kConfigMacMavericks:
       case kConfigMacYosemite:
       case kConfigMacElCapitan:
+      case kConfigMacSierra:
       case kConfigMac:
       case kConfigLinux:
       case kConfigChromeOS:
@@ -322,7 +327,7 @@ bool GPUTestExpectationsParser::ParseLine(
   std::vector<std::string> tokens = base::SplitString(
       line_data, base::kWhitespaceASCII, base::KEEP_WHITESPACE,
       base::SPLIT_WANT_NONEMPTY);
-  int32 stage = kLineParserBegin;
+  int32_t stage = kLineParserBegin;
   GPUTestExpectationEntry entry;
   entry.line_number = line_number;
   GPUTestConfig& config = entry.test_config;
@@ -346,6 +351,7 @@ bool GPUTestExpectationsParser::ParseLine(
       case kConfigMacMavericks:
       case kConfigMacYosemite:
       case kConfigMacElCapitan:
+      case kConfigMacSierra:
       case kConfigMac:
       case kConfigLinux:
       case kConfigChromeOS:
@@ -430,7 +436,7 @@ bool GPUTestExpectationsParser::ParseLine(
           stage++;
         break;
       default:
-        UNREACHABLE();
+        DCHECK(false);
         break;
     }
   }
@@ -450,8 +456,9 @@ bool GPUTestExpectationsParser::ParseLine(
   return false;
 }
 
-bool GPUTestExpectationsParser::UpdateTestConfig(
-    GPUTestConfig* config, int32 token, size_t line_number) {
+bool GPUTestExpectationsParser::UpdateTestConfig(GPUTestConfig* config,
+                                                 int32_t token,
+                                                 size_t line_number) {
   DCHECK(config);
   switch (token) {
     case kConfigWinXP:
@@ -467,6 +474,7 @@ bool GPUTestExpectationsParser::UpdateTestConfig(
     case kConfigMacMavericks:
     case kConfigMacYosemite:
     case kConfigMacElCapitan:
+    case kConfigMacSierra:
     case kConfigMac:
     case kConfigLinux:
     case kConfigChromeOS:
@@ -483,8 +491,7 @@ bool GPUTestExpectationsParser::UpdateTestConfig(
     case kConfigIntel:
     case kConfigVMWare:
       {
-        uint32 gpu_vendor =
-            static_cast<uint32>(kTokenData[token].flag);
+      uint32_t gpu_vendor = static_cast<uint32_t>(kTokenData[token].flag);
         for (size_t i = 0; i < config->gpu_vendor().size(); ++i) {
           if (config->gpu_vendor()[i] == gpu_vendor) {
             PushErrorMessage(
@@ -519,7 +526,7 @@ bool GPUTestExpectationsParser::UpdateTestConfig(
       config->set_api(config->api() | kTokenData[token].flag);
       break;
     default:
-      UNREACHABLE();
+      DCHECK(false);
       break;
   }
   return true;
@@ -530,7 +537,7 @@ bool GPUTestExpectationsParser::UpdateTestConfig(
     const std::string& gpu_device_id,
     size_t line_number) {
   DCHECK(config);
-  uint32 device_id = 0;
+  uint32_t device_id = 0;
   if (config->gpu_device_id() != 0 ||
       !base::HexStringToUInt(gpu_device_id, &device_id) ||
       device_id == 0) {
@@ -560,18 +567,17 @@ bool GPUTestExpectationsParser::DetectConflictsBetweenEntries() {
 
 void GPUTestExpectationsParser::PushErrorMessage(
     const std::string& message, size_t line_number) {
-    std::ostringstream stream;
-    stream << "Line " << line_number << " : " << message;
-    error_messages_.push_back(stream.str());
+  error_messages_.push_back("Line " + ToString(line_number) +
+                            " : " + message.c_str());
 }
 
 void GPUTestExpectationsParser::PushErrorMessage(
     const std::string& message,
     size_t entry1_line_number,
     size_t entry2_line_number) {
-    std::ostringstream stream;
-    stream << "Line " << entry1_line_number << " and " << entry2_line_number << " : " << message;
-    error_messages_.push_back(stream.str());
+  error_messages_.push_back("Line " + ToString(entry1_line_number) +
+                            " and " + ToString(entry2_line_number) +
+                            " : " + message.c_str());
 }
 
 GPUTestExpectationsParser:: GPUTestExpectationEntry::GPUTestExpectationEntry()

src/tests/third_party/gpu_test_expectations/gpu_test_expectations_parser.h

@@ -2,8 +2,11 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef GPU_CONFIG_GPU_TEST_EXPECTATIONS_PARSER_H_
-#define GPU_CONFIG_GPU_TEST_EXPECTATIONS_PARSER_H_
+#ifndef ANGLE_GPU_CONFIG_GPU_TEST_EXPECTATIONS_PARSER_H_
+#define ANGLE_GPU_CONFIG_GPU_TEST_EXPECTATIONS_PARSER_H_
+
+#include <stddef.h>
+#include <stdint.h>
 
 #include <string>
 #include <vector>
@@ -36,8 +39,8 @@ class GPU_EXPORT GPUTestExpectationsParser {
   const std::vector<std::string>& GetErrorMessages() const;
 
   // Get the test expectation of a given test on a given bot.
-  int32 GetTestExpectation(const std::string& test_name,
-                           const GPUTestBotConfig& bot_config) const;
+  int32_t GetTestExpectation(const std::string& test_name,
+                             const GPUTestBotConfig& bot_config) const;
 
   // Parse a list of config modifiers. If we have a valid entry with no
   // conflicts, | config | stores it, and the function returns true.
@@ -49,7 +52,7 @@ class GPU_EXPORT GPUTestExpectationsParser {
 
     std::string test_name;
     GPUTestConfig test_config;
-    int32 test_expectation;
+    int32_t test_expectation;
     size_t line_number;
   };
 
@@ -58,8 +61,9 @@ class GPU_EXPORT GPUTestExpectationsParser {
   bool ParseLine(const std::string& line_data, size_t line_number);
 
   // Update OS/GPUVendor/BuildType modifiers. May generate an error message.
-  bool UpdateTestConfig(
-      GPUTestConfig* config, int32 token, size_t line_number);
+  bool UpdateTestConfig(GPUTestConfig* config,
+                        int32_t token,
+                        size_t line_number);
 
   // Update GPUDeviceID modifier. May generate an error message.
   bool UpdateTestConfig(GPUTestConfig* config,
@@ -82,5 +86,5 @@ class GPU_EXPORT GPUTestExpectationsParser {
 
 }  // namespace gpu
 
-#endif  // GPU_CONFIG_GPU_TEST_EXPECTATIONS_PARSER_H_
+#endif  // ANGLE_GPU_CONFIG_GPU_TEST_EXPECTATIONS_PARSER_H_