Moving the contents of chrome://gpu Profiling to chrome://tracing.

content/browser/gpu/gpu_data_manager.cc

 // Copyright (c) 2011 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/gpu/gpu_data_manager.h"
 
 #if defined(OS_MACOSX)
 #include <CoreGraphics/CGDisplayConfiguration.h>
 #endif
 
@@ skipping 22 matching lines @@
             << base::StringPrintf("%04x", flags);
   if (flags & kCGDisplayAddFlag) {
     GpuDataManager* manager =
         reinterpret_cast<GpuDataManager*>(gpu_data_manager);
     DCHECK(manager);
     manager->HandleGpuSwitch();
   }
 }
 #endif
 
+DictionaryValue* NewDescriptionValuePair(const std::string& desc,
+    const std::string& value) {
+  DictionaryValue* dict = new DictionaryValue();
+  dict->SetString("description", desc);
+  dict->SetString("value", value);
+  return dict;
+}
+
+DictionaryValue* NewDescriptionValuePair(const std::string& desc,
+    Value* value) {
+  DictionaryValue* dict = new DictionaryValue();
+  dict->SetString("description", desc);
+  dict->Set("value", value);
+  return dict;
+}
+
+#if defined(OS_WIN)
+// Output DxDiagNode tree as nested array of {description,value} pairs
+ListValue* DxDiagNodeToList(const DxDiagNode& node) {
+  ListValue* list = new ListValue();
+  for (std::map<std::string, std::string>::const_iterator it =
+      node.values.begin();
+      it != node.values.end();
+      ++it) {
+    list->Append(NewDescriptionValuePair(it->first, it->second));
+  }
+
+  for (std::map<std::string, DxDiagNode>::const_iterator it =
+      node.children.begin();
+      it != node.children.end();
+      ++it) {
+    ListValue* sublist = DxDiagNodeToList(it->second);
+    list->Append(NewDescriptionValuePair(it->first, sublist));
+  }
+  return list;
+}
+
+#endif  // OS_WIN
+
 }  // namespace anonymous
 
 GpuDataManager::GpuDataManager()
     : complete_gpu_info_already_requested_(false) {
   // Certain tests doesn't go through the browser startup path that
   // initializes GpuDataManager on FILE thread; therefore, it is initialized
   // on UI thread later, and we skip the preliminary gpu info collection
   // in such situation.
   if (!BrowserThread::CurrentlyOn(BrowserThread::FILE))
     return;
@@ skipping 183 matching lines @@
   GPUInfo gpu_info;
   gpu_info_collector::CollectVideoCardInfo(&gpu_info);
   LOG(INFO) << "Switching to use GPU: vendor_id = 0x"
             << base::StringPrintf("%04x", gpu_info.vendor_id)
             << ", device_id = 0x"
             << base::StringPrintf("%04x", gpu_info.device_id);
   // TODO(zmo): update gpu_info_, re-run blacklist logic, maybe close and
   // relaunch GPU process.
 }
 
+DictionaryValue* GpuDataManager::GpuInfoAsDictionaryValue() const {
+  ListValue* basic_info = new ListValue();
+  basic_info->Append(NewDescriptionValuePair(
+      "Initialization time",
+      base::Int64ToString(gpu_info().initialization_time.InMilliseconds())));
+  basic_info->Append(NewDescriptionValuePair(
+      "Vendor Id", base::StringPrintf("0x%04x", gpu_info().vendor_id)));
+  basic_info->Append(NewDescriptionValuePair(
+      "Device Id", base::StringPrintf("0x%04x", gpu_info().device_id)));
+  basic_info->Append(NewDescriptionValuePair("Driver vendor",
+                                             gpu_info().driver_vendor));
+  basic_info->Append(NewDescriptionValuePair("Driver version",
+                                             gpu_info().driver_version));
+  basic_info->Append(NewDescriptionValuePair("Driver date",
+                                             gpu_info().driver_date));
+  basic_info->Append(NewDescriptionValuePair("Pixel shader version",
+                                             gpu_info().pixel_shader_version));
+  basic_info->Append(NewDescriptionValuePair("Vertex shader version",
+                                             gpu_info().vertex_shader_version));
+  basic_info->Append(NewDescriptionValuePair("GL version",
+                                             gpu_info().gl_version));
+  basic_info->Append(NewDescriptionValuePair("GL_VENDOR",
+                                             gpu_info().gl_vendor));
+  basic_info->Append(NewDescriptionValuePair("GL_RENDERER",
+                                             gpu_info().gl_renderer));
+  basic_info->Append(NewDescriptionValuePair("GL_VERSION",
+                                             gpu_info().gl_version_string));
+  basic_info->Append(NewDescriptionValuePair("GL_EXTENSIONS",
+                                             gpu_info().gl_extensions));
+
+  DictionaryValue* info = new DictionaryValue();
+  info->Set("basic_info", basic_info);
+
+#if defined(OS_WIN)
+  Value* dx_info;
+  if (gpu_info().dx_diagnostics.children.size())
+    dx_info = DxDiagNodeToList(gpu_info().dx_diagnostics);
+  else
+    dx_info = Value::CreateNullValue();
+  info->Set("diagnostics", dx_info);
+#endif
+
+  return info;
+}
+
 void GpuDataManager::RunGpuInfoUpdateCallbacks() {
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
         NewRunnableMethod(this, &GpuDataManager::RunGpuInfoUpdateCallbacks));
     return;
   }
 
   std::set<Callback0::Type*>::iterator i = gpu_info_update_callbacks_.begin();
   for (; i != gpu_info_update_callbacks_.end(); ++i) {
     (*i)->Run();
@@ skipping 47 matching lines @@
   const CommandLine& browser_command_line = *CommandLine::ForCurrentProcess();
   if (browser_command_line.HasSwitch(switches::kIgnoreGpuBlacklist) ||
       browser_command_line.GetSwitchValueASCII(
           switches::kUseGL) == gfx::kGLImplementationOSMesaName)
     return NULL;
   // No need to return an empty blacklist.
   if (gpu_blacklist_.get() != NULL && gpu_blacklist_->max_entry_id() == 0)
     return NULL;
   return gpu_blacklist_.get();
 }