Show Compositor information in chrome://gpu

content/browser/gpu/gpu_internals_ui.cc

 // Copyright (c) 2012 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_internals_ui.h"
 
 #include <stddef.h>
 
 #include <string>
 
@@ skipping 284 matching lines @@
       return "SCANOUT";
     case gfx::BufferUsage::GPU_READ_CPU_READ_WRITE:
       return "GPU_READ_CPU_READ_WRITE";
     case gfx::BufferUsage::GPU_READ_CPU_READ_WRITE_PERSISTENT:
       return "GPU_READ_CPU_READ_WRITE_PERSISTENT";
   }
   NOTREACHED();
   return nullptr;
 }
 
-base::DictionaryValue* GpuMemoryBufferInfoAsDictionaryValue() {
+base::ListValue* CompositorInfo() {
+  base::ListValue* compositor_info = new base::ListValue();
+
+  // Add Tile Update Mode.
+  std::string tile_update_mode;
+  if (BrowserGpuMemoryBufferManager::IsNativeGpuMemoryBuffersEnabled()) {

[reveman, 2016/01/29 19:49:07]

Don't include this here. This information is already made visible using
kNativeGpuMemoryBuffersFeatureName above.

[dshwang, 2016/01/29 19:58:40]

Done.

+    tile_update_mode = "Native, ";
+  } else {
+    tile_update_mode = "Software, ";
+  }
+  if (IsZeroCopyUploadEnabled()) {
+    tile_update_mode += "Zero-copy";
+  } else {
+    tile_update_mode += "One-copy";
+  }
+  compositor_info->Append(
+      NewDescriptionValuePair("Tile Update Mode", tile_update_mode));
+
+  // Add Partial Raster
+  compositor_info->Append(NewDescriptionValuePair(
+      "Partial Raster", IsPartialRasterEnabled() ? "Enabled" : "Disabled"));
+  return compositor_info;
+}
+
+base::ListValue* GpuMemoryBufferInfo() {
   base::ListValue* gpu_memory_buffer_info = new base::ListValue();
 
   BrowserGpuMemoryBufferManager* gpu_memory_buffer_manager =
       BrowserGpuMemoryBufferManager::current();
 
   for (size_t format = 0;
        format < static_cast<size_t>(gfx::BufferFormat::LAST) + 1; format++) {
     std::string native_usage_support;
     for (size_t usage = 0;
          usage < static_cast<size_t>(gfx::BufferUsage::LAST) + 1; usage++) {
       if (gpu_memory_buffer_manager->IsNativeGpuMemoryBufferConfiguration(
               static_cast<gfx::BufferFormat>(format),
               static_cast<gfx::BufferUsage>(usage)))
         native_usage_support = base::StringPrintf(
             "%s%s %s", native_usage_support.c_str(),
             native_usage_support.empty() ? "" : ",",
             BufferUsageToString(static_cast<gfx::BufferUsage>(usage)));
     }
     if (native_usage_support.empty())
       native_usage_support = base::StringPrintf("Software only");
 
     gpu_memory_buffer_info->Append(NewDescriptionValuePair(
         BufferFormatToString(static_cast<gfx::BufferFormat>(format)),
         native_usage_support));
   }
-
-  base::DictionaryValue* info = new base::DictionaryValue();
-  info->Set("gpu_memory_buffer_info", gpu_memory_buffer_info);
-
-  return info;
+  return gpu_memory_buffer_info;
 }
 
 // This class receives javascript messages from the renderer.
 // Note that the WebUI infrastructure runs on the UI thread, therefore all of
 // this class's methods are expected to run on the UI thread.
 class GpuMessageHandler
     : public WebUIMessageHandler,
       public base::SupportsWeakPtr<GpuMessageHandler>,
       public GpuDataManagerObserver,
       public ui::GpuSwitchingObserver {
@@ skipping 155 matching lines @@
 
   // Add in blacklisting features
   base::DictionaryValue* feature_status = new base::DictionaryValue;
   feature_status->Set("featureStatus", GetFeatureStatus());
   feature_status->Set("problems", GetProblems());
   base::ListValue* workarounds = new base::ListValue();
   for (const std::string& workaround : GetDriverBugWorkarounds())
     workarounds->AppendString(workaround);
   feature_status->Set("workarounds", workarounds);
   gpu_info_val->Set("featureStatus", feature_status);
+  gpu_info_val->Set("compositorInfo", CompositorInfo());
+  gpu_info_val->Set("gpuMemoryBufferInfo", GpuMemoryBufferInfo());
 
   // Send GPU Info to javascript.
   web_ui()->CallJavascriptFunction("browserBridge.onGpuInfoUpdate",
       *(gpu_info_val.get()));
-
-  // Get GpuMemoryBuffer Info.
-  scoped_ptr<base::DictionaryValue> gpu_memory_buffer_info_val(
-      GpuMemoryBufferInfoAsDictionaryValue());
-
-  // Send GpuMemoryBuffer Info to javascript.
-  web_ui()->CallJavascriptFunction("browserBridge.onGpuMemoryBufferInfoUpdate",
-                                   *(gpu_memory_buffer_info_val.get()));
 }
 
 void GpuMessageHandler::OnGpuSwitched() {
   GpuDataManagerImpl::GetInstance()->RequestCompleteGpuInfoIfNeeded();
 }
 
 }  // namespace
 
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // GpuInternalsUI
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 GpuInternalsUI::GpuInternalsUI(WebUI* web_ui)
     : WebUIController(web_ui) {
   web_ui->AddMessageHandler(new GpuMessageHandler());
 
   // Set up the chrome://gpu/ source.
   BrowserContext* browser_context =
       web_ui->GetWebContents()->GetBrowserContext();
   WebUIDataSource::Add(browser_context, CreateGpuHTMLSource());
 }
 
 }  // namespace content