Expose GPU information to Telemetry.

gpu/config/gpu_info.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "gpu/config/gpu_info.h"
 
 namespace gpu {
 
 GPUInfo::GPUDevice::GPUDevice()
     : vendor_id(0),
       device_id(0) {
 }
 
 GPUInfo::GPUDevice::~GPUDevice() { }
 
 GPUInfo::GPUInfo()
     : finalized(false),
       optimus(false),
       amd_switchable(false),
       lenovo_dcute(false),
       adapter_luid(0),
       gl_reset_notification_strategy(0),
       can_lose_context(false),
       software_rendering(false),
       sandboxed(false) {
 }
 
 GPUInfo::~GPUInfo() { }
 
+void GPUInfo::EnumerateFields(Enumerator* enumerator) const {
+  struct GPUInfoKnownFields {
+    bool finalized;
+    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;
+    std::string driver_vendor;
+    std::string driver_version;
+    std::string driver_date;
+    std::string pixel_shader_version;
+    std::string vertex_shader_version;
+    std::string machine_model;
+    std::string gl_version;
+    std::string gl_version_string;
+    std::string gl_vendor;
+    std::string gl_renderer;
+    std::string gl_extensions;
+    std::string gl_ws_vendor;
+    std::string gl_ws_version;
+    std::string gl_ws_extensions;
+    bool can_lose_context;
+    GpuPerformanceStats performance_stats;
+    bool software_rendering;
+    bool sandboxed;
+#if defined(OS_WIN)
+    DxDiagNode dx_diagnostics;
+#endif
+  };
+
+  // If this assert fails then most likely something below needs to be updated.
+  // Note that this assert is only approximate. If a new field is added to
+  // GPUInfo which fits within the current padding then it will not be caught.
+  COMPILE_ASSERT(
+      sizeof(GPUInfo) == sizeof(GPUInfoKnownFields),
+      Fields_Have_Changed_In_GPUInfo_So_Update_Below);
+
+  // Note that we use the C++, and Python, naming convention for these
+  // fields. The final consumer of this information is Telemetry's Python
+  // classes, and using a consistent naming convention reduces the amount
+  // of code that must be written converting back and forth.
+  enumerator->AddBool("finalized", finalized);
+  enumerator->AddTimeDeltaInSecondsF("initialization_time",
+                                     initialization_time);
+  enumerator->AddBool("optimus", optimus);
+  enumerator->AddBool("amd_switchable", amd_switchable);
+  enumerator->AddBool("lenovo_dcute", lenovo_dcute);
+  if (display_link_version.IsValid()) {
+    enumerator->AddString("display_link_version",
+                          display_link_version.GetString());
+  }
+  enumerator->AddGPUDevice(gpu);
+  for (size_t ii = 0; ii < secondary_gpus.size(); ++ii) {
+    enumerator->AddGPUDevice(secondary_gpus[ii]);
+  }
+  enumerator->AddInt64("adapter_luid", adapter_luid);
+  enumerator->AddString("driver_vendor", driver_vendor);
+  enumerator->AddString("driver_version", driver_version);
+  enumerator->AddString("driver_date", driver_date);
+  enumerator->AddString("pixel_shader_version", pixel_shader_version);
+  enumerator->AddString("vertex_shader_version", vertex_shader_version);
+  enumerator->AddString("machine_model", machine_model);
+  enumerator->AddString("gl_version", gl_version);
+  enumerator->AddString("gl_version_string", gl_version_string);
+  enumerator->AddString("gl_vendor", gl_vendor);
+  enumerator->AddString("gl_renderer", gl_renderer);
+  enumerator->AddString("gl_extensions", gl_extensions);
+  enumerator->AddString("gl_ws_vendor", gl_ws_vendor);
+  enumerator->AddString("gl_ws_version", gl_ws_version);
+  enumerator->AddString("gl_ws_extensions", gl_ws_extensions);
+  enumerator->AddBool("can_lose_context", can_lose_context);
+  // TODO(kbr): add performance_stats.
+  enumerator->AddBool("software_rendering", software_rendering);
+  enumerator->AddBool("sandboxed", sandboxed);
+  // TODO(kbr): add dx_diagnostics on Windows.
+}
+
 }  // namespace gpu