Home | History | Annotate | Download | only in devtools 
      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:
     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 BeginAuxAttributes() OVERRIDE {
     70     in_aux_attributes_ = true;
     71   }
     72 
     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 
     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 
     94 DevToolsSystemInfoHandler::DevToolsSystemInfoHandler() {
     95   RegisterCommandHandler(devtools::SystemInfo::getInfo::kName,
     96                          base::Bind(&DevToolsSystemInfoHandler::OnGetInfo,
     97                                     base::Unretained(this)));
     98 }
     99 
    100 DevToolsSystemInfoHandler::~DevToolsSystemInfoHandler() {
    101 }
    102 
    103 scoped_refptr<DevToolsProtocol::Response>
    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