1// Copyright 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 "content/browser/devtools/devtools_system_info_handler.h"
6
7#include "base/bind.h"
8#include "base/callback.h"
9#include "base/values.h"
10#include "content/browser/devtools/devtools_protocol_constants.h"
11#include "content/browser/gpu/compositor_util.h"
12#include "content/browser/gpu/gpu_data_manager_impl.h"
13#include "gpu/config/gpu_info.h"
14
15namespace content {
16
17namespace {
18
19const char kAuxAttributes[] = "auxAttributes";
20const char kDeviceId[] = "deviceId";
21const char kDeviceString[] = "deviceString";
22const char kDevices[] = "devices";
23const char kDriverBugWorkarounds[] = "driverBugWorkarounds";
24const char kFeatureStatus[] = "featureStatus";
25const char kGPU[] = "gpu";
26const char kModelName[] = "modelName";
27const char kModelVersion[] = "modelVersion";
28const char kVendorId[] = "vendorId";
29const char kVendorString[] = "vendorString";
30
31class AuxGPUInfoEnumerator : public gpu::GPUInfo::Enumerator {
32 public:
33  AuxGPUInfoEnumerator(base::DictionaryValue* dictionary)
34      : dictionary_(dictionary),
35        in_aux_attributes_(false) { }
36
37  virtual void AddInt64(const char* name, int64 value) OVERRIDE {
38    if (in_aux_attributes_)
39      dictionary_->SetDouble(name, value);
40  }
41
42  virtual void AddInt(const char* name, int value) OVERRIDE {
43    if (in_aux_attributes_)
44      dictionary_->SetInteger(name, value);
45  }
46
47  virtual void AddString(const char* name, const std::string& value) OVERRIDE {
48    if (in_aux_attributes_)
49      dictionary_->SetString(name, value);
50  }
51
52  virtual void AddBool(const char* name, bool value) OVERRIDE {
53    if (in_aux_attributes_)
54      dictionary_->SetBoolean(name, value);
55  }
56
57  virtual void AddTimeDeltaInSecondsF(const char* name,
58                                      const base::TimeDelta& value) OVERRIDE {
59    if (in_aux_attributes_)
60      dictionary_->SetDouble(name, value.InSecondsF());
61  }
62
63  virtual void BeginGPUDevice() OVERRIDE {
64  }
65
66  virtual void EndGPUDevice() OVERRIDE {
67  }
68
69  virtual void BeginVideoEncodeAcceleratorSupportedProfile() OVERRIDE {}
70
71  virtual void EndVideoEncodeAcceleratorSupportedProfile() OVERRIDE {}
72
73  virtual void BeginAuxAttributes() OVERRIDE {
74    in_aux_attributes_ = true;
75  }
76
77  virtual void EndAuxAttributes() OVERRIDE {
78    in_aux_attributes_ = false;
79  }
80
81 private:
82  base::DictionaryValue* dictionary_;
83  bool in_aux_attributes_;
84};
85
86base::DictionaryValue* GPUDeviceToDictionary(
87    const gpu::GPUInfo::GPUDevice& device) {
88  base::DictionaryValue* result = new base::DictionaryValue;
89  result->SetInteger(kVendorId, device.vendor_id);
90  result->SetInteger(kDeviceId, device.device_id);
91  result->SetString(kVendorString, device.vendor_string);
92  result->SetString(kDeviceString, device.device_string);
93  return result;
94}
95
96}  // namespace
97
98DevToolsSystemInfoHandler::DevToolsSystemInfoHandler() {
99  RegisterCommandHandler(devtools::SystemInfo::getInfo::kName,
100                         base::Bind(&DevToolsSystemInfoHandler::OnGetInfo,
101                                    base::Unretained(this)));
102}
103
104DevToolsSystemInfoHandler::~DevToolsSystemInfoHandler() {
105}
106
107scoped_refptr<DevToolsProtocol::Response>
108DevToolsSystemInfoHandler::OnGetInfo(
109    scoped_refptr<DevToolsProtocol::Command> command) {
110  gpu::GPUInfo gpu_info = GpuDataManagerImpl::GetInstance()->GetGPUInfo();
111  base::DictionaryValue* gpu_dict = new base::DictionaryValue;
112
113  base::ListValue* devices = new base::ListValue;
114  devices->Append(GPUDeviceToDictionary(gpu_info.gpu));
115  for (size_t ii = 0; ii < gpu_info.secondary_gpus.size(); ++ii) {
116    devices->Append(GPUDeviceToDictionary(gpu_info.secondary_gpus[ii]));
117  }
118  gpu_dict->Set(kDevices, devices);
119
120  base::DictionaryValue* aux_attributes = new base::DictionaryValue;
121  AuxGPUInfoEnumerator enumerator(aux_attributes);
122  gpu_info.EnumerateFields(&enumerator);
123  gpu_dict->Set(kAuxAttributes, aux_attributes);
124
125  gpu_dict->Set(kFeatureStatus,  GetFeatureStatus());
126
127  gpu_dict->Set(kDriverBugWorkarounds, GetDriverBugWorkarounds());
128
129  base::DictionaryValue* system_dict = new base::DictionaryValue;
130  system_dict->SetString(kModelName, gpu_info.machine_model_name);
131  system_dict->SetString(kModelVersion, gpu_info.machine_model_version);
132  system_dict->Set(kGPU, gpu_dict);
133  return command->SuccessResponse(system_dict);
134}
135
136}  // namespace content
137