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(),
+          "GpuMemoryByffer is using the fall back path through shared memory"
+          " instead the hardware backed one.",

[reveman, 2015/09/29 11:58:02]

This is not completely true. Just because native GMBs are enabled doesn't mean
that they can be used. It depends on the format and usage, which is determined
by a number of settings such as usage of tile compression. Video pipeline uses
R8 or one of the YUV formats and compositor is likely using RGBA8888 or BGRA888.
I don't think it's a good idea to expose a feature that is supposed to tell if
native GMBs are used or not. It would give a lot of false positives.

+          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.

[reveman, 2015/09/29 11:58:02]

That's why this gets messy and I don't think it's a good idea. One buffer might
have a native backing but another might not and a IsNativeGpuMemoryBufferEnabled
function that returns true if the configs below are happens to be supported is
going to be confusing.

However, it would be nice to surface whether native GMBs are enabled or not and
might be used. Either as a feature or as an about:flag. I think an about:flag
would be useful for debugging purposes now that we enable this on more
platforms. That allows a user to change it as well as see what the current value
is.

The difference compared to this patch will be that there's no guarantee that
native GMBs are used just because the flag is enabled. You'll need to capture a
trace to be sure. Just like the current --enable-native-gpu-memory-buffers
switch. The flag will just mirror that switch.

+  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