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