Move gpu blacklist to content side.

content/browser/gpu/gpu_util.cc

Index: content/browser/gpu/gpu_util.cc
===================================================================
--- content/browser/gpu/gpu_util.cc	(revision 154773)
+++ content/browser/gpu/gpu_util.cc	(working copy)
@@ -2,32 +2,18 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "chrome/browser/gpu_util.h"
+#include "content/browser/gpu/gpu_util.h"
 
 #include <vector>
 
 #include "base/command_line.h"
-#include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
-#include "base/string_number_conversions.h"
 #include "base/string_util.h"
-#include "base/stringprintf.h"
 #include "base/sys_info.h"
-#include "base/values.h"
 #include "base/version.h"
-#include "chrome/browser/gpu_blacklist.h"
-#include "chrome/common/chrome_version_info.h"
-#include "content/public/browser/gpu_data_manager.h"
-#include "content/public/common/compositor_util.h"
-#include "content/public/common/content_constants.h"
+#include "content/browser/gpu/gpu_blacklist.h"
 #include "content/public/common/content_switches.h"
-#include "content/public/common/gpu_info.h"
 
-#if defined(OS_WIN)
-#include "base/win/windows_version.h"
-#endif
-
-using content::GpuDataManager;
 using content::GpuFeatureType;
 
 namespace {
@@ -50,60 +36,6 @@
     kGpuFeatureNumStatus
 };
 
-struct GpuFeatureInfo {
-  std::string name;
-  uint32 blocked;
-  bool disabled;
-  std::string disabled_description;
-  bool fallback_to_software;
-};
-
-// Determine if accelerated-2d-canvas is supported, which depends on whether
-// lose_context could happen and whether skia is the backend.
-bool SupportsAccelerated2dCanvas() {
-  if (GpuDataManager::GetInstance()->GetGPUInfo().can_lose_context)
-    return false;
-#if defined(USE_SKIA)
-  return true;
-#else
-  return false;
-#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;
-}
-
-Value* NewStatusValue(const char* name, const char* status) {
-  DictionaryValue* value = new DictionaryValue();
-  value->SetString("name", name);
-  value->SetString("status", status);
-  return value;
-}
-
-std::string GPUDeviceToString(const content::GPUInfo::GPUDevice& gpu) {
-  std::string vendor = base::StringPrintf("0x%04x", gpu.vendor_id);
-  if (!gpu.vendor_string.empty())
-    vendor += " [" + gpu.vendor_string + "]";
-  std::string device = base::StringPrintf("0x%04x", gpu.device_id);
-  if (!gpu.device_string.empty())
-    device += " [" + gpu.device_string + "]";
-  return base::StringPrintf(
-      "VENDOR = %s, DEVICE= %s", vendor.c_str(), device.c_str());
-}
-
 #if defined(OS_WIN)
 
 enum WinSubVersion {
@@ -114,26 +46,6 @@
   kNumWinSubVersions
 };
 
-// Output DxDiagNode tree as nested array of {description,value} pairs
-ListValue* DxDiagNodeToList(const content::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, content::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;
-}
-
 int GetGpuBlacklistHistogramValueWin(GpuFeatureStatus status) {
   static WinSubVersion sub_version = kNumWinSubVersions;
   if (sub_version == kNumWinSubVersions) {
@@ -172,81 +84,6 @@
 
 namespace gpu_util {
 
-void InitializeCompositingFieldTrial() {
-// Enable the field trial only on desktop OS's.
-#if !(defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX))
-  return;
-#endif
-#if defined(OS_WIN)
-  // Don't run the trial on Windows XP.
-  if (base::win::GetVersion() < base::win::VERSION_VISTA)
-    return;
-#endif
-
-  // The performance of accelerated compositing is too low with software
-  // rendering.
-  if (content::GpuDataManager::GetInstance()->ShouldUseSoftwareRendering())
-    return;
-
-  // Don't activate the field trial if force-compositing-mode has been
-  // explicitly disabled from the command line.
-  if (CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kDisableForceCompositingMode))
-    return;
-
-  const base::FieldTrial::Probability kDivisor = 3;
-  scoped_refptr<base::FieldTrial> trial(
-    base::FieldTrialList::FactoryGetFieldTrial(
-        content::kGpuCompositingFieldTrialName, kDivisor,
-        "disable", 2012, 12, 31, NULL));
-
-  // Produce the same result on every run of this client.
-  trial->UseOneTimeRandomization();
-
-  base::FieldTrial::Probability force_compositing_mode_probability = 0;
-  base::FieldTrial::Probability threaded_compositing_probability = 0;
-
-  chrome::VersionInfo::Channel channel = chrome::VersionInfo::GetChannel();
-  if (channel == chrome::VersionInfo::CHANNEL_STABLE ||
-      channel == chrome::VersionInfo::CHANNEL_BETA) {
-    // Stable and Beta channels: Non-threaded force-compositing-mode on by
-    // default (mac and windows only).
-#if defined(OS_WIN) || defined(OS_MACOSX)
-    force_compositing_mode_probability = 3;
-#endif
-  } else if (channel == chrome::VersionInfo::CHANNEL_DEV ||
-             channel == chrome::VersionInfo::CHANNEL_CANARY) {
-    // Dev and Canary channels: force-compositing-mode and
-    // threaded-compositing on with 1/3 probability each.
-    force_compositing_mode_probability = 1;
-
-#if defined(OS_MACOSX) || defined(OS_LINUX)
-    // Threaded compositing mode isn't feature complete on mac or linux yet:
-    // http://crbug.com/133602 for mac
-    // http://crbug.com/140866 for linux
-    threaded_compositing_probability = 0;
-#else
-    if (!CommandLine::ForCurrentProcess()->HasSwitch(
-            switches::kDisableThreadedCompositing))
-        threaded_compositing_probability = 1;
-#endif
-  }
-
-
-  int force_compositing_group = trial->AppendGroup(
-      content::kGpuCompositingFieldTrialForceCompositingEnabledName,
-      force_compositing_mode_probability);
-  int thread_group = trial->AppendGroup(
-      content::kGpuCompositingFieldTrialThreadEnabledName,
-      threaded_compositing_probability);
-
-  bool force_compositing = (trial->group() == force_compositing_group);
-  bool thread = (trial->group() == thread_group);
-  UMA_HISTOGRAM_BOOLEAN("GPU.InForceCompositingModeFieldTrial",
-                        force_compositing);
-  UMA_HISTOGRAM_BOOLEAN("GPU.InCompositorThreadFieldTrial", thread);
-}
-
 GpuFeatureType StringToGpuFeatureType(const std::string& feature_string) {
   if (feature_string == kGpuFeatureNameAccelerated2dCanvas)
     return content::GPU_FEATURE_TYPE_ACCELERATED_2D_CANVAS;
@@ -288,260 +125,16 @@
       matches.push_back(kGpuFeatureNameFlashStage3d);
     if (type & content::GPU_FEATURE_TYPE_TEXTURE_SHARING)
       matches.push_back(kGpuFeatureNameTextureSharing);
+    if (type & content::GPU_FEATURE_TYPE_ACCELERATED_VIDEO_DECODE)
+      matches.push_back(kGpuFeatureNameAcceleratedVideoDecode);
     if (!matches.size())
       matches.push_back(kGpuFeatureNameUnknown);
   }
   return JoinString(matches, ',');
 }
 
-Value* GetFeatureStatus() {
-  const CommandLine& command_line = *CommandLine::ForCurrentProcess();
-  bool gpu_access_blocked = !GpuDataManager::GetInstance()->GpuAccessAllowed();
-
-  uint32 flags = GpuDataManager::GetInstance()->GetBlacklistedFeatures();
-  DictionaryValue* status = new DictionaryValue();
-
-  const GpuFeatureInfo kGpuFeatureInfo[] = {
-      {
-          "2d_canvas",
-          flags & content::GPU_FEATURE_TYPE_ACCELERATED_2D_CANVAS,
-          command_line.HasSwitch(switches::kDisableAccelerated2dCanvas) ||
-          !SupportsAccelerated2dCanvas(),
-          "Accelerated 2D canvas is unavailable: either disabled at the command"
-          " line or not supported by the current system.",
-          true
-      },
-      {
-          "compositing",
-          flags & content::GPU_FEATURE_TYPE_ACCELERATED_COMPOSITING,
-          command_line.HasSwitch(switches::kDisableAcceleratedCompositing),
-          "Accelerated compositing has been disabled, either via about:flags or"
-          " command line. This adversely affects performance of all hardware"
-          " accelerated features.",
-          true
-      },
-      {
-          "3d_css",
-          flags & content::GPU_FEATURE_TYPE_ACCELERATED_COMPOSITING,
-          command_line.HasSwitch(switches::kDisableAcceleratedLayers),
-          "Accelerated layers have been disabled at the command line.",
-          false
-      },
-      {
-          "css_animation",
-          flags & content::GPU_FEATURE_TYPE_ACCELERATED_COMPOSITING,
-          command_line.HasSwitch(switches::kDisableThreadedAnimation) ||
-          command_line.HasSwitch(switches::kDisableAcceleratedCompositing),
-          "Accelerated CSS animation has been disabled at the command line.",
-          true
-      },
-      {
-          "webgl",
-          flags & content::GPU_FEATURE_TYPE_WEBGL,
-#if defined(OS_ANDROID)
-          !command_line.HasSwitch(switches::kEnableExperimentalWebGL),
-#else
-          command_line.HasSwitch(switches::kDisableExperimentalWebGL),
-#endif
-          "WebGL has been disabled, either via about:flags or command line.",
-          false
-      },
-      {
-          "multisampling",
-          flags & content::GPU_FEATURE_TYPE_MULTISAMPLING,
-          command_line.HasSwitch(switches::kDisableGLMultisampling),
-          "Multisampling has been disabled, either via about:flags or command"
-          " line.",
-          false
-      },
-      {
-          "flash_3d",
-          flags & content::GPU_FEATURE_TYPE_FLASH3D,
-          command_line.HasSwitch(switches::kDisableFlash3d),
-          "Using 3d in flash has been disabled, either via about:flags or"
-          " command line.",
-          false
-      },
-      {
-          "flash_stage3d",
-          flags & content::GPU_FEATURE_TYPE_FLASH_STAGE3D,
-          command_line.HasSwitch(switches::kDisableFlashStage3d),
-          "Using Stage3d in Flash has been disabled, either via about:flags or"
-          " command line.",
-          false
-      },
-      {
-          "texture_sharing",
-          flags & content::GPU_FEATURE_TYPE_TEXTURE_SHARING,
-          command_line.HasSwitch(switches::kDisableImageTransportSurface),
-          "Sharing textures between processes has been disabled, either via"
-          " about:flags or command line.",
-          false
-      },
-      {
-          "video_decode",
-          flags & content::GPU_FEATURE_TYPE_ACCELERATED_VIDEO_DECODE,
-          command_line.HasSwitch(switches::kDisableAcceleratedVideoDecode),
-          "Accelerated video decode has been disabled, either via about:flags"
-          " or command line.",
-          true
-      }
-  };
-  const size_t kNumFeatures = sizeof(kGpuFeatureInfo) / sizeof(GpuFeatureInfo);
-
-  // Build the feature_status field.
-  {
-    ListValue* feature_status_list = new ListValue();
-
-    for (size_t i = 0; i < kNumFeatures; ++i) {
-      std::string status;
-      if (kGpuFeatureInfo[i].disabled) {
-        status = "disabled";
-        if (kGpuFeatureInfo[i].name == "css_animation") {
-          status += "_software_animated";
-        } else {
-          if (kGpuFeatureInfo[i].fallback_to_software)
-            status += "_software";
-          else
-            status += "_off";
-        }
-      } else if (GpuDataManager::GetInstance()->ShouldUseSoftwareRendering()) {
-        status = "unavailable_software";
-      } else if (kGpuFeatureInfo[i].blocked ||
-                 gpu_access_blocked) {
-        status = "unavailable";
-        if (kGpuFeatureInfo[i].fallback_to_software)
-          status += "_software";
-        else
-          status += "_off";
-      } else {
-        status = "enabled";
-        if (kGpuFeatureInfo[i].name == "webgl" &&
-            (command_line.HasSwitch(switches::kDisableAcceleratedCompositing) ||
-             (flags & content::GPU_FEATURE_TYPE_ACCELERATED_COMPOSITING)))
-          status += "_readback";
-        bool has_thread = content::IsThreadedCompositingEnabled();
-        if (kGpuFeatureInfo[i].name == "compositing") {
-          bool force_compositing =
-              content::IsForceCompositingModeEnabled();
-          if (force_compositing)
-            status += "_force";
-          if (has_thread)
-            status += "_threaded";
-        }
-        if (kGpuFeatureInfo[i].name == "css_animation") {
-          if (has_thread)
-            status = "accelerated_threaded";
-          else
-            status = "accelerated";
-        }
-      }
-      feature_status_list->Append(
-          NewStatusValue(kGpuFeatureInfo[i].name.c_str(), status.c_str()));
-    }
-
-    status->Set("featureStatus", feature_status_list);
-  }
-
-  // Build the problems list.
-  {
-    ListValue* problem_list = new ListValue();
-
-    if (gpu_access_blocked) {
-      DictionaryValue* problem = new DictionaryValue();
-      problem->SetString("description",
-          "GPU process was unable to boot. Access to GPU disallowed.");
-      problem->Set("crBugs", new ListValue());
-      problem->Set("webkitBugs", new ListValue());
-      problem_list->Append(problem);
-    }
-
-    for (size_t i = 0; i < kNumFeatures; ++i) {
-      if (kGpuFeatureInfo[i].disabled) {
-        DictionaryValue* problem = new DictionaryValue();
-        problem->SetString(
-            "description", kGpuFeatureInfo[i].disabled_description);
-        problem->Set("crBugs", new ListValue());
-        problem->Set("webkitBugs", new ListValue());
-        problem_list->Append(problem);
-      }
-    }
-
-    GpuBlacklist::GetInstance()->GetBlacklistReasons(problem_list);
-
-    status->Set("problems", problem_list);
-  }
-
-  return status;
-}
-
-DictionaryValue* GpuInfoAsDictionaryValue() {
-  content::GPUInfo gpu_info = GpuDataManager::GetInstance()->GetGPUInfo();
-  ListValue* basic_info = new ListValue();
-  basic_info->Append(NewDescriptionValuePair(
-      "Initialization time",
-      base::Int64ToString(gpu_info.initialization_time.InMilliseconds())));
-  basic_info->Append(NewDescriptionValuePair(
-      "GPU0", GPUDeviceToString(gpu_info.gpu)));
-  for (size_t i = 0; i < gpu_info.secondary_gpus.size(); ++i) {
-    basic_info->Append(NewDescriptionValuePair(
-        base::StringPrintf("GPU%d", static_cast<int>(i + 1)),
-        GPUDeviceToString(gpu_info.secondary_gpus[i])));
-  }
-  basic_info->Append(NewDescriptionValuePair(
-      "Optimus", Value::CreateBooleanValue(gpu_info.optimus)));
-  basic_info->Append(NewDescriptionValuePair(
-      "AMD switchable", Value::CreateBooleanValue(gpu_info.amd_switchable)));
-  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)
-  ListValue* perf_info = new ListValue();
-  perf_info->Append(NewDescriptionValuePair(
-      "Graphics",
-      base::StringPrintf("%.1f", gpu_info.performance_stats.graphics)));
-  perf_info->Append(NewDescriptionValuePair(
-      "Gaming",
-      base::StringPrintf("%.1f", gpu_info.performance_stats.gaming)));
-  perf_info->Append(NewDescriptionValuePair(
-      "Overall",
-      base::StringPrintf("%.1f", gpu_info.performance_stats.overall)));
-  info->Set("performance_info", perf_info);
-
-  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 UpdateStats() {
-  GpuBlacklist* blacklist = GpuBlacklist::GetInstance();
+void UpdateStats(const GpuBlacklist* blacklist,
+                 uint32 blacklisted_features) {
   uint32 max_entry_id = blacklist->max_entry_id();
   if (max_entry_id == 0) {
     // GPU Blacklist was not loaded.  No need to go further.
@@ -549,9 +142,8 @@
   }
 
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
-  uint32 flags = GpuDataManager::GetInstance()->GetBlacklistedFeatures();
   bool disabled = false;
-  if (flags == 0) {
+  if (blacklisted_features == 0) {
     UMA_HISTOGRAM_ENUMERATION("GPU.BlacklistTestResultsPerEntry",
         0, max_entry_id + 1);
   } else {
@@ -608,7 +200,7 @@
     // We can't use UMA_HISTOGRAM_ENUMERATION here because the same name is
     // expected if the macro is used within a loop.
     GpuFeatureStatus value = kGpuFeatureEnabled;
-    if (flags & kGpuFeatures[i])
+    if (blacklisted_features & kGpuFeatures[i])
       value = kGpuFeatureBlacklisted;
     else if (kGpuFeatureUserFlags[i])
       value = kGpuFeatureDisabled;