Expose GPU information to Telemetry.

content/browser/devtools/devtools_system_info_handler.cc

+// Copyright (c) 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "content/browser/devtools/devtools_system_info_handler.h"
+
+#include "base/bind.h"
+#include "base/callback.h"
+#include "base/values.h"
+#include "content/browser/devtools/devtools_protocol_constants.h"
+#include "content/browser/gpu/gpu_data_manager_impl.h"
+#include "gpu/config/gpu_info.h"
+
+namespace content {
+
+namespace {
+
+const char kGPU[] = "gpu";

[pfeldman, 2013/08/07 13:01:58]

How is this information going to be used? Do you intend to make vendorId,
deviceId, etc. public and commit to its maintenance? If so, we might need to
come up with browser_protocol.json (like protocol.json) that would describe the
scheme.

[Ken Russell (switch to Gerrit), 2013/08/08 02:42:37]

The CL description describes how it's going to be used. Currently I have no plan
to document and publicize this information. It is required in order to cut over
many GPU tests to the Telemetry harness, which is a top priority for our group.

[Ken Russell (switch to Gerrit), 2013/08/14 00:54:40]

Per discussion above, I've uploaded https://codereview.chromium.org/22980005 to
document the new methods and types in the SystemInfo domain. It seemed that it
fit properly within the existing protocol.json along other domains such as
Tracing.

+const char kVendorId[] = "vendor_id";

[pfeldman, 2013/08/07 13:01:58]

Please use camelCase for property names.

[Ken Russell (switch to Gerrit), 2013/08/08 02:42:37]

Is this strictly necessary? Doing so is going to require a bunch of boilerplate
conversion code because Python's naming convention differs from JavaScript's.
The only goal here is to expose these fields to Python. JavaScript is a
necessary intermediary.

[Ken Russell (switch to Gerrit), 2013/08/14 00:54:40]

Done. Also modified GPUInfo::EnumerateFields in gpu_info.cc to use camelCase. A
new helper class in Telemetry converts to the underscore naming convention used
throughout its Python code.

+const char kDeviceId[] = "device_id";
+const char kVendorString[] = "vendor_string";
+const char kDeviceString[] = "device_string";
+const char kSecondaryGPUs[] = "secondary_gpus";
+
+class GPUInfoEnumerator : public gpu::GPUInfo::Enumerator {
+ public:
+  GPUInfoEnumerator(base::DictionaryValue* dictionary)
+      : dictionary_(dictionary) { }
+
+  virtual void AddInt64(const char* name, int64 value) OVERRIDE {
+    dictionary_->SetDouble(name, value);
+  }
+
+  virtual void AddString(const char* name, const std::string& value) OVERRIDE {
+    dictionary_->SetString(name, value);
+  }
+
+  virtual void AddBool(const char* name, bool value) OVERRIDE {
+    dictionary_->SetBoolean(name, value);
+  }
+
+  virtual void AddTimeDeltaInSecondsF(const char* name,
+                                      const base::TimeDelta& value) OVERRIDE {
+    dictionary_->SetDouble(name, value.InSecondsF());
+  }
+
+  virtual void AddGPUDevice(const gpu::GPUInfo::GPUDevice& device) OVERRIDE {
+    base::DictionaryValue* gpu_device = new base::DictionaryValue;
+
+    // Ideally this logic would be in GPUInfo::EnumerateFields, but
+    // describing nested objects would be difficult, and add
+    // undesirable state to the Enumerator.
+    gpu_device->SetInteger(kVendorId, device.vendor_id);
+    gpu_device->SetInteger(kDeviceId, device.device_id);
+    gpu_device->SetString(kVendorString, device.vendor_string);
+    gpu_device->SetString(kDeviceString, device.device_string);
+
+    if (!dictionary_->HasKey(kGPU)) {
+      dictionary_->Set(kGPU, gpu_device);
+      return;
+    }
+
+    base::ListValue* secondary_gpus = NULL;
+    if (dictionary_->HasKey(kSecondaryGPUs)) {
+      bool success = dictionary_->GetList(kSecondaryGPUs, &secondary_gpus);
+      DCHECK(success);
+    } else {
+      secondary_gpus = new base::ListValue;
+      dictionary_->Set(kSecondaryGPUs, secondary_gpus);
+    }
+
+    secondary_gpus->Append(gpu_device);
+  }
+
+ private:
+  base::DictionaryValue* dictionary_;
+};
+
+}  // namespace
+
+DevToolsSystemInfoHandler::DevToolsSystemInfoHandler() {
+  RegisterCommandHandler(devtools::SystemInfo::getGPUInfo::kName,
+                         base::Bind(&DevToolsSystemInfoHandler::OnGetGPUInfo,
+                                    base::Unretained(this)));
+}
+
+DevToolsSystemInfoHandler::~DevToolsSystemInfoHandler() {
+}
+
+scoped_ptr<DevToolsProtocol::Response>
+DevToolsSystemInfoHandler::OnGetGPUInfo(DevToolsProtocol::Command* command) {
+  gpu::GPUInfo gpu_info = GpuDataManagerImpl::GetInstance()->GetGPUInfo();
+  base::DictionaryValue* result = new base::DictionaryValue;
+  GPUInfoEnumerator enumerator(result);
+  gpu_info.EnumerateFields(&enumerator);
+  return command->SuccessResponse(result);
+}
+
+}  // namespace content