content/browser/gpu/gpu_internals_ui.cc

   1 // Copyright (c) 2012 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/gpu/gpu_internals_ui.h"
   6
   7 #include <string>
   8
   9 #include "base/bind.h"
  10 #include "base/bind_helpers.h"
  11 #include "base/command_line.h"
  12 #include "base/i18n/time_formatting.h"
  13 #include "base/strings/string_number_conversions.h"
  14 #include "base/strings/stringprintf.h"
  15 #include "base/sys_info.h"
  16 #include "base/values.h"
  17 #include "content/browser/gpu/compositor_util.h"
  18 #include "content/browser/gpu/gpu_data_manager_impl.h"
  19 #include "content/public/browser/browser_thread.h"
  20 #include "content/public/browser/gpu_data_manager_observer.h"
  21 #include "content/public/browser/web_contents.h"
  22 #include "content/public/browser/web_ui.h"
  23 #include "content/public/browser/web_ui_data_source.h"
  24 #include "content/public/browser/web_ui_message_handler.h"
  25 #include "content/public/common/content_client.h"
  26 #include "content/public/common/content_switches.h"
  27 #include "content/public/common/url_constants.h"
  28 #include "gpu/config/gpu_feature_type.h"
  29 #include "gpu/config/gpu_info.h"
  30 #include "grit/content_resources.h"
  31 #include "third_party/angle/src/common/version.h"
  32
  33 #if defined(OS_WIN)
  34 #include "ui/base/win/shell.h"
  35 #endif
  36
  37 namespace content {
  38 namespace {
  39
  40 WebUIDataSource* CreateGpuHTMLSource() {
  41   WebUIDataSource* source = WebUIDataSource::Create(kChromeUIGpuHost);
  42
  43   source->SetJsonPath("strings.js");
  44   source->AddResourcePath("gpu_internals.js", IDR_GPU_INTERNALS_JS);
  45   source->SetDefaultResource(IDR_GPU_INTERNALS_HTML);
  46   return source;
  47 }
  48
  49 base::DictionaryValue* NewDescriptionValuePair(const std::string& desc,
  50     const std::string& value) {
  51   base::DictionaryValue* dict = new base::DictionaryValue();
  52   dict->SetString("description", desc);
  53   dict->SetString("value", value);
  54   return dict;
  55 }
  56
  57 base::DictionaryValue* NewDescriptionValuePair(const std::string& desc,
  58     base::Value* value) {
  59   base::DictionaryValue* dict = new base::DictionaryValue();
  60   dict->SetString("description", desc);
  61   dict->Set("value", value);
  62   return dict;
  63 }
  64
  65 #if defined(OS_WIN)
  66 // Output DxDiagNode tree as nested array of {description,value} pairs
  67 base::ListValue* DxDiagNodeToList(const gpu::DxDiagNode& node) {
  68   base::ListValue* list = new base::ListValue();
  69   for (std::map<std::string, std::string>::const_iterator it =
  70       node.values.begin();
  71       it != node.values.end();
  72       ++it) {
  73     list->Append(NewDescriptionValuePair(it->first, it->second));
  74   }
  75
  76   for (std::map<std::string, gpu::DxDiagNode>::const_iterator it =
  77       node.children.begin();
  78       it != node.children.end();
  79       ++it) {
  80     base::ListValue* sublist = DxDiagNodeToList(it->second);
  81     list->Append(NewDescriptionValuePair(it->first, sublist));
  82   }
  83   return list;
  84 }
  85 #endif
  86
  87 std::string GPUDeviceToString(const gpu::GPUInfo::GPUDevice& gpu) {
  88   std::string vendor = base::StringPrintf("0x%04x", gpu.vendor_id);
  89   if (!gpu.vendor_string.empty())
  90     vendor += " [" + gpu.vendor_string + "]";
  91   std::string device = base::StringPrintf("0x%04x", gpu.device_id);
  92   if (!gpu.device_string.empty())
  93     device += " [" + gpu.device_string + "]";
  94   return base::StringPrintf("VENDOR = %s, DEVICE= %s%s",
  95       vendor.c_str(), device.c_str(), gpu.active ? " *ACTIVE*" : "");
  96 }
  97
  98 base::DictionaryValue* GpuInfoAsDictionaryValue() {
  99   gpu::GPUInfo gpu_info = GpuDataManagerImpl::GetInstance()->GetGPUInfo();
 100   base::ListValue* basic_info = new base::ListValue();
 101   basic_info->Append(NewDescriptionValuePair(
 102       "Initialization time",
 103       base::Int64ToString(gpu_info.initialization_time.InMilliseconds())));
 104   basic_info->Append(NewDescriptionValuePair(
 105       "Sandboxed", new base::FundamentalValue(gpu_info.sandboxed)));
 106   basic_info->Append(NewDescriptionValuePair(
 107       "GPU0", GPUDeviceToString(gpu_info.gpu)));
 108   for (size_t i = 0; i < gpu_info.secondary_gpus.size(); ++i) {
 109     basic_info->Append(NewDescriptionValuePair(
 110         base::StringPrintf("GPU%d", static_cast<int>(i + 1)),
 111         GPUDeviceToString(gpu_info.secondary_gpus[i])));
 112   }
 113   basic_info->Append(NewDescriptionValuePair(
 114       "Optimus", new base::FundamentalValue(gpu_info.optimus)));
 115   basic_info->Append(NewDescriptionValuePair(
 116       "AMD switchable", new base::FundamentalValue(gpu_info.amd_switchable)));
 117   if (gpu_info.lenovo_dcute) {
 118     basic_info->Append(NewDescriptionValuePair(
 119         "Lenovo dCute", new base::FundamentalValue(true)));
 120   }
 121   if (gpu_info.display_link_version.IsValid()) {
 122     basic_info->Append(NewDescriptionValuePair(
 123         "DisplayLink Version", gpu_info.display_link_version.GetString()));
 124   }
 125 #if defined(OS_WIN)
 126   std::string compositor =
 127       ui::win::IsAeroGlassEnabled() ? "Aero Glass" : "none";
 128   basic_info->Append(
 129       NewDescriptionValuePair("Desktop compositing", compositor));
 130 #endif
 131
 132   basic_info->Append(
 133       NewDescriptionValuePair("Driver vendor", gpu_info.driver_vendor));
 134   basic_info->Append(NewDescriptionValuePair("Driver version",
 135                                              gpu_info.driver_version));
 136   basic_info->Append(NewDescriptionValuePair("Driver date",
 137                                              gpu_info.driver_date));
 138   basic_info->Append(NewDescriptionValuePair("Pixel shader version",
 139                                              gpu_info.pixel_shader_version));
 140   basic_info->Append(NewDescriptionValuePair("Vertex shader version",
 141                                              gpu_info.vertex_shader_version));
 142   basic_info->Append(NewDescriptionValuePair("Machine model name",
 143                                              gpu_info.machine_model_name));
 144   basic_info->Append(NewDescriptionValuePair("Machine model version",
 145                                              gpu_info.machine_model_version));
 146   basic_info->Append(NewDescriptionValuePair("GL_VENDOR",
 147                                              gpu_info.gl_vendor));
 148   basic_info->Append(NewDescriptionValuePair("GL_RENDERER",
 149                                              gpu_info.gl_renderer));
 150   basic_info->Append(NewDescriptionValuePair("GL_VERSION",
 151                                              gpu_info.gl_version));
 152   basic_info->Append(NewDescriptionValuePair("GL_EXTENSIONS",
 153                                              gpu_info.gl_extensions));
 154   basic_info->Append(NewDescriptionValuePair("Window system binding vendor",
 155                                              gpu_info.gl_ws_vendor));
 156   basic_info->Append(NewDescriptionValuePair("Window system binding version",
 157                                              gpu_info.gl_ws_version));
 158   basic_info->Append(NewDescriptionValuePair("Window system binding extensions",
 159                                              gpu_info.gl_ws_extensions));
 160   std::string direct_rendering = gpu_info.direct_rendering ? "Yes" : "No";
 161   basic_info->Append(
 162       NewDescriptionValuePair("Direct rendering", direct_rendering));
 163
 164   std::string reset_strategy =
 165       base::StringPrintf("0x%04x", gpu_info.gl_reset_notification_strategy);
 166   basic_info->Append(NewDescriptionValuePair(
 167       "Reset notification strategy", reset_strategy));
 168
 169   base::DictionaryValue* info = new base::DictionaryValue();
 170   info->Set("basic_info", basic_info);
 171
 172 #if defined(OS_WIN)
 173   base::ListValue* perf_info = new base::ListValue();
 174   perf_info->Append(NewDescriptionValuePair(
 175       "Graphics",
 176       base::StringPrintf("%.1f", gpu_info.performance_stats.graphics)));
 177   perf_info->Append(NewDescriptionValuePair(
 178       "Gaming",
 179       base::StringPrintf("%.1f", gpu_info.performance_stats.gaming)));
 180   perf_info->Append(NewDescriptionValuePair(
 181       "Overall",
 182       base::StringPrintf("%.1f", gpu_info.performance_stats.overall)));
 183   info->Set("performance_info", perf_info);
 184
 185   base::Value* dx_info = gpu_info.dx_diagnostics.children.size() ?
 186     DxDiagNodeToList(gpu_info.dx_diagnostics) :
 187     base::Value::CreateNullValue();
 188   info->Set("diagnostics", dx_info);
 189 #endif
 190
 191   return info;
 192 }
 193
 194 // This class receives javascript messages from the renderer.
 195 // Note that the WebUI infrastructure runs on the UI thread, therefore all of
 196 // this class's methods are expected to run on the UI thread.
 197 class GpuMessageHandler
 198     : public WebUIMessageHandler,
 199       public base::SupportsWeakPtr<GpuMessageHandler>,
 200       public GpuDataManagerObserver {
 201  public:
 202   GpuMessageHandler();
 203   virtual ~GpuMessageHandler();
 204
 205   // WebUIMessageHandler implementation.
 206   virtual void RegisterMessages() OVERRIDE;
 207
 208   // GpuDataManagerObserver implementation.
 209   virtual void OnGpuInfoUpdate() OVERRIDE;
 210   virtual void OnGpuSwitching() OVERRIDE;
 211
 212   // Messages
 213   void OnBrowserBridgeInitialized(const base::ListValue* list);
 214   void OnCallAsync(const base::ListValue* list);
 215
 216   // Submessages dispatched from OnCallAsync
 217   base::Value* OnRequestClientInfo(const base::ListValue* list);
 218   base::Value* OnRequestLogMessages(const base::ListValue* list);
 219
 220  private:
 221   // True if observing the GpuDataManager (re-attaching as observer would
 222   // DCHECK).
 223   bool observing_;
 224
 225   DISALLOW_COPY_AND_ASSIGN(GpuMessageHandler);
 226 };
 227
 228 ////////////////////////////////////////////////////////////////////////////////
 229 //
 230 // GpuMessageHandler
 231 //
 232 ////////////////////////////////////////////////////////////////////////////////
 233
 234 GpuMessageHandler::GpuMessageHandler()
 235     : observing_(false) {
 236 }
 237
 238 GpuMessageHandler::~GpuMessageHandler() {
 239   GpuDataManagerImpl::GetInstance()->RemoveObserver(this);
 240 }
 241
 242 /* BrowserBridge.callAsync prepends a requestID to these messages. */
 243 void GpuMessageHandler::RegisterMessages() {
 244   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 245
 246   web_ui()->RegisterMessageCallback("browserBridgeInitialized",
 247       base::Bind(&GpuMessageHandler::OnBrowserBridgeInitialized,
 248                  base::Unretained(this)));
 249   web_ui()->RegisterMessageCallback("callAsync",
 250       base::Bind(&GpuMessageHandler::OnCallAsync,
 251                  base::Unretained(this)));
 252 }
 253
 254 void GpuMessageHandler::OnCallAsync(const base::ListValue* args) {
 255   DCHECK_GE(args->GetSize(), static_cast<size_t>(2));
 256   // unpack args into requestId, submessage and submessageArgs
 257   bool ok;
 258   const base::Value* requestId;
 259   ok = args->Get(0, &requestId);
 260   DCHECK(ok);
 261
 262   std::string submessage;
 263   ok = args->GetString(1, &submessage);
 264   DCHECK(ok);
 265
 266   base::ListValue* submessageArgs = new base::ListValue();
 267   for (size_t i = 2; i < args->GetSize(); ++i) {
 268     const base::Value* arg;
 269     ok = args->Get(i, &arg);
 270     DCHECK(ok);
 271
 272     base::Value* argCopy = arg->DeepCopy();
 273     submessageArgs->Append(argCopy);
 274   }
 275
 276   // call the submessage handler
 277   base::Value* ret = NULL;
 278   if (submessage == "requestClientInfo") {
 279     ret = OnRequestClientInfo(submessageArgs);
 280   } else if (submessage == "requestLogMessages") {
 281     ret = OnRequestLogMessages(submessageArgs);
 282   } else {  // unrecognized submessage
 283     NOTREACHED();
 284     delete submessageArgs;
 285     return;
 286   }
 287   delete submessageArgs;
 288
 289   // call BrowserBridge.onCallAsyncReply with result
 290   if (ret) {
 291     web_ui()->CallJavascriptFunction("browserBridge.onCallAsyncReply",
 292         *requestId,
 293         *ret);
 294     delete ret;
 295   } else {
 296     web_ui()->CallJavascriptFunction("browserBridge.onCallAsyncReply",
 297         *requestId);
 298   }
 299 }
 300
 301 void GpuMessageHandler::OnBrowserBridgeInitialized(
 302     const base::ListValue* args) {
 303   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 304
 305   // Watch for changes in GPUInfo
 306   if (!observing_)
 307     GpuDataManagerImpl::GetInstance()->AddObserver(this);
 308   observing_ = true;
 309
 310   // Tell GpuDataManager it should have full GpuInfo. If the
 311   // Gpu process has not run yet, this will trigger its launch.
 312   GpuDataManagerImpl::GetInstance()->RequestCompleteGpuInfoIfNeeded();
 313
 314   // Run callback immediately in case the info is ready and no update in the
 315   // future.
 316   OnGpuInfoUpdate();
 317 }
 318
 319 base::Value* GpuMessageHandler::OnRequestClientInfo(
 320     const base::ListValue* list) {
 321   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 322
 323   base::DictionaryValue* dict = new base::DictionaryValue();
 324
 325   dict->SetString("version", GetContentClient()->GetProduct());
 326   dict->SetString("command_line",
 327       CommandLine::ForCurrentProcess()->GetCommandLineString());
 328   dict->SetString("operating_system",
 329                   base::SysInfo::OperatingSystemName() + " " +
 330                   base::SysInfo::OperatingSystemVersion());
 331   dict->SetString("angle_commit_id", ANGLE_COMMIT_HASH);
 332   dict->SetString("graphics_backend", "Skia");
 333   dict->SetString("blacklist_version",
 334       GpuDataManagerImpl::GetInstance()->GetBlacklistVersion());
 335   dict->SetString("driver_bug_list_version",
 336       GpuDataManagerImpl::GetInstance()->GetDriverBugListVersion());
 337
 338   return dict;
 339 }
 340
 341 base::Value* GpuMessageHandler::OnRequestLogMessages(const base::ListValue*) {
 342   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 343
 344   return GpuDataManagerImpl::GetInstance()->GetLogMessages();
 345 }
 346
 347 void GpuMessageHandler::OnGpuInfoUpdate() {
 348   // Get GPU Info.
 349   scoped_ptr<base::DictionaryValue> gpu_info_val(GpuInfoAsDictionaryValue());
 350
 351   // Add in blacklisting features
 352   base::DictionaryValue* feature_status = new base::DictionaryValue;
 353   feature_status->Set("featureStatus", GetFeatureStatus());
 354   feature_status->Set("problems", GetProblems());
 355   feature_status->Set("workarounds", GetDriverBugWorkarounds());
 356   if (feature_status)
 357     gpu_info_val->Set("featureStatus", feature_status);
 358
 359   // Send GPU Info to javascript.
 360   web_ui()->CallJavascriptFunction("browserBridge.onGpuInfoUpdate",
 361       *(gpu_info_val.get()));
 362 }
 363
 364 void GpuMessageHandler::OnGpuSwitching() {
 365   GpuDataManagerImpl::GetInstance()->RequestCompleteGpuInfoIfNeeded();
 366 }
 367
 368 }  // namespace
 369
 370
 371 ////////////////////////////////////////////////////////////////////////////////
 372 //
 373 // GpuInternalsUI
 374 //
 375 ////////////////////////////////////////////////////////////////////////////////
 376
 377 GpuInternalsUI::GpuInternalsUI(WebUI* web_ui)
 378     : WebUIController(web_ui) {
 379   web_ui->AddMessageHandler(new GpuMessageHandler());
 380
 381   // Set up the chrome://gpu/ source.
 382   BrowserContext* browser_context =
 383       web_ui->GetWebContents()->GetBrowserContext();
 384   WebUIDataSource::Add(browser_context, CreateGpuHTMLSource());
 385 }
 386
 387 }  // namespace content