Show GpuMemoryBuffer feature in chrome://gpu

content/browser/gpu/compositor_util.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/compositor_util.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/sys_info.h"
 #include "build/build_config.h"
 #include "cc/base/math_util.h"
 #include "cc/base/switches.h"
+#include "content/browser/gpu/browser_gpu_memory_buffer_manager.h"
 #include "content/browser/gpu/gpu_data_manager_impl.h"
 #include "content/public/common/content_switches.h"
 #include "gpu/config/gpu_feature_type.h"
 
 namespace content {
 
 namespace {
 
 static bool IsGpuRasterizationBlacklisted() {
   GpuDataManagerImpl* manager = GpuDataManagerImpl::GetInstance();
   return manager->IsFeatureBlacklisted(
         gpu::GPU_FEATURE_TYPE_GPU_RASTERIZATION);
 }
 
 const char* kGpuCompositingFeatureName = "gpu_compositing";
 const char* kWebGLFeatureName = "webgl";
 const char* kRasterizationFeatureName = "rasterization";
 const char* kMultipleRasterThreadsFeatureName = "multiple_raster_threads";
+const char* kGpuMemoryBufferFeatureName = "gpu_memory_buffer";
 
 const int kMinRasterThreads = 1;
 const int kMaxRasterThreads = 4;
 
 const int kMinMSAASampleCount = 0;
 
 struct GpuFeatureInfo {
   std::string name;
   bool blocked;
   bool disabled;
@@ skipping 100 matching lines @@
           " or command line.",
           true
       },
       {
           kMultipleRasterThreadsFeatureName,
           false,
           NumberOfRendererRasterThreads() == 1,
           "Raster is using a single thread.",
           false
       },
+      {
+          kGpuMemoryBufferFeatureName,
+          false,
+          !IsNativeGpuMemoryBufferEnabled(),
+          "Raster is using fallback (shm).",

[Ken Russell (switch to Gerrit), 2015/09/28 23:00:14]

Could you elaborate on the description here? Perhaps at least "Raster is using
fallback path (shared memory, instead of zero- or one-copy)".

[vignatti (out of this project), 2015/09/28 23:15:09]

Done.

+          true
+      },
   };
   DCHECK(index < arraysize(kGpuFeatureInfo));
   *eof = (index == arraysize(kGpuFeatureInfo) - 1);
   return kGpuFeatureInfo[index];
 }
 
 }  // namespace
 
 bool IsPropertyTreeVerificationEnabled() {
   const base::CommandLine& command_line =
@@ skipping 38 matching lines @@
 bool IsZeroCopyUploadEnabled() {
   const base::CommandLine& command_line =
       *base::CommandLine::ForCurrentProcess();
 #if defined(OS_MACOSX)
   return !command_line.HasSwitch(switches::kDisableZeroCopy);
 #else
   return command_line.HasSwitch(switches::kEnableZeroCopy);
 #endif
 }
 
+bool IsNativeGpuMemoryBufferEnabled() {
+  const auto& command_line = *base::CommandLine::ForCurrentProcess();
+  bool enabled =
+      command_line.HasSwitch(switches::kEnableNativeGpuMemoryBuffers);
+  BrowserGpuMemoryBufferManager* gmb_manager =
+      BrowserGpuMemoryBufferManager::current();
+
+  // We need buffer mapping configuration to proper support native GMB.
+  enabled &= gmb_manager->IsGpuMemoryBufferConfigurationSupported(
+        gfx::BufferFormat::BGRA_8888, gfx::BufferUsage::MAP) |
+             gmb_manager->IsGpuMemoryBufferConfigurationSupported(
+        gfx::BufferFormat::BGRA_8888, gfx::BufferUsage::PERSISTENT_MAP);
+  return enabled;
+}
+
 bool IsPersistentGpuMemoryBufferEnabled() {
   // Zero copy currently doesn't take advantage of persistent buffers.
   if (IsZeroCopyUploadEnabled())
     return false;
   const auto& command_line = *base::CommandLine::ForCurrentProcess();
   return command_line.HasSwitch(switches::kEnablePersistentGpuMemoryBuffer);
 }
 
 bool IsGpuRasterizationEnabled() {
   const base::CommandLine& command_line =
@@ skipping 93 matching lines @@
         status += "_off";
     } else {
       status = "enabled";
       if (gpu_feature_info.name == kWebGLFeatureName &&
           manager->IsFeatureBlacklisted(gpu::GPU_FEATURE_TYPE_GPU_COMPOSITING))
         status += "_readback";
       if (gpu_feature_info.name == kRasterizationFeatureName) {
         if (IsForceGpuRasterizationEnabled())
           status += "_force";
       }
+      if (gpu_feature_info.name == kGpuMemoryBufferFeatureName) {
+        status += "_native";
+        if (IsZeroCopyUploadEnabled())
+          status += "_zero_copy";
+        else
+          status += "_one_copy";
+      }
       if (gpu_feature_info.name == kMultipleRasterThreadsFeatureName) {
         const base::CommandLine& command_line =
             *base::CommandLine::ForCurrentProcess();
         if (command_line.HasSwitch(switches::kNumRasterThreads))
           status += "_force";
       }
       if (gpu_feature_info.name == kMultipleRasterThreadsFeatureName)
         status += "_on";
     }
     if (gpu_feature_info.name == kWebGLFeatureName &&
@@ skipping 47 matching lines @@
     }
   }
   return problem_list;
 }
 
 std::vector<std::string> GetDriverBugWorkarounds() {
   return GpuDataManagerImpl::GetInstance()->GetDriverBugWorkarounds();
 }
 
 }  // namespace content