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"
@@ skipping 12 matching lines @@
 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* kNativeGpuMemoryBufferFeatureName = "native_gpu_memory_buffers";

[reveman, 2015/10/16 18:37:43]

s/GpuMemoryBuffer/GpuMemoryBuffers/

 
 const int kMinRasterThreads = 1;
 const int kMaxRasterThreads = 4;
 
 const int kMinMSAASampleCount = 0;
 
 struct GpuFeatureInfo {
   std::string name;
   bool blocked;
   bool disabled;
@@ skipping 106 matching lines @@
           NumberOfRendererRasterThreads() == 1,
           "Raster is using a single thread.",
           false
       },
   };
   DCHECK(index < arraysize(kGpuFeatureInfo));
   *eof = (index == arraysize(kGpuFeatureInfo) - 1);
   return kGpuFeatureInfo[index];
 }
 
+const GpuFeatureInfo GetGpuGmbInfo(size_t index, bool* eof) {
+  const GpuFeatureInfo kGpuGmbInfo[] = {
+      {
+          kNativeGpuMemoryBufferFeatureName,
+          false,
+          !IsNativeGpuMemoryBufferEnabled(),
+          "GpuMemoryBuffers are using the fall back path through shared memory"
+          " instead the hardware backed one.",
+          true
+      },
+  };
+  DCHECK(index < arraysize(kGpuGmbInfo));
+  *eof = (index == arraysize(kGpuGmbInfo) - 1);
+  return kGpuGmbInfo[index];
+}
+
 }  // namespace
 
 bool IsPropertyTreeVerificationEnabled() {
   const base::CommandLine& command_line =
       *base::CommandLine::ForCurrentProcess();
   return command_line.HasSwitch(cc::switches::kEnablePropertyTreeVerification);
 }
 
 int NumberOfRendererRasterThreads() {
   int num_processors = base::SysInfo::NumberOfProcessors();
@@ skipping 32 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() {

[reveman, 2015/10/16 18:37:43]

The logic used to determine if enable_native_gpu_memory_buffers variable in
GetNativeGpuMemoryBufferConfigurations (browser_gpu_memory_buffer_manager.cc) is
true should move here.

+  const auto& command_line = *base::CommandLine::ForCurrentProcess();
+  return command_line.HasSwitch(switches::kEnableNativeGpuMemoryBuffers);
+}
+
 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 114 matching lines @@
         manager->ShouldUseSwiftShader()) {
       status = "unavailable_software";
     }
 
     feature_status_dict->SetString(
         gpu_feature_info.name.c_str(), status.c_str());
   }
   return feature_status_dict;
 }
 
+base::DictionaryValue* GetGmbStatus() {
+  base::DictionaryValue* feature_status_dict = new base::DictionaryValue();
+
+  bool eof = false;
+  for (size_t i = 0; !eof; ++i) {
+    const GpuFeatureInfo gpu_gmb_info = GetGpuGmbInfo(i, &eof);
+    std::string status;
+    if (gpu_gmb_info.disabled) {
+      status = "disabled_software";
+    } else {
+      status = "enabled_on";
+    }
+
+    feature_status_dict->SetString(
+        gpu_gmb_info.name.c_str(), status.c_str());
+  }
+  return feature_status_dict;
+}
+
 base::Value* GetProblems() {
   GpuDataManagerImpl* manager = GpuDataManagerImpl::GetInstance();
   std::string gpu_access_blocked_reason;
   bool gpu_access_blocked =
       !manager->GpuAccessAllowed(&gpu_access_blocked_reason);
 
   base::ListValue* problem_list = new base::ListValue();
   manager->GetBlacklistReasons(problem_list);
 
   if (gpu_access_blocked) {
@@ skipping 26 matching lines @@
     }
   }
   return problem_list;
 }
 
 std::vector<std::string> GetDriverBugWorkarounds() {
   return GpuDataManagerImpl::GetInstance()->GetDriverBugWorkarounds();
 }
 
 }  // namespace content