Add accelerated_video_decode as a GPU blacklist feature.

chrome/browser/gpu_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 "chrome/browser/gpu_util.h"
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/metrics/field_trial.h"
@@ skipping 22 matching lines @@
 
 namespace {
 
 const char kGpuFeatureNameAccelerated2dCanvas[] = "accelerated_2d_canvas";
 const char kGpuFeatureNameAcceleratedCompositing[] = "accelerated_compositing";
 const char kGpuFeatureNameWebgl[] = "webgl";
 const char kGpuFeatureNameMultisampling[] = "multisampling";
 const char kGpuFeatureNameFlash3d[] = "flash_3d";
 const char kGpuFeatureNameFlashStage3d[] = "flash_stage3d";
 const char kGpuFeatureNameTextureSharing[] = "texture_sharing";
+const char kGpuFeatureNameAcceleratedVideoDecode[] = "accelerated_video_decode";
 const char kGpuFeatureNameAll[] = "all";
 const char kGpuFeatureNameUnknown[] = "unknown";
 
 enum GpuFeatureStatus {
     kGpuFeatureEnabled = 0,
     kGpuFeatureBlacklisted = 1,
     kGpuFeatureDisabled = 2,  // disabled by user but not blacklisted
     kGpuFeatureNumStatus
 };
 
@@ skipping 198 matching lines @@
   else if (feature_string == kGpuFeatureNameWebgl)
     return content::GPU_FEATURE_TYPE_WEBGL;
   else if (feature_string == kGpuFeatureNameMultisampling)
     return content::GPU_FEATURE_TYPE_MULTISAMPLING;
   else if (feature_string == kGpuFeatureNameFlash3d)
     return content::GPU_FEATURE_TYPE_FLASH3D;
   else if (feature_string == kGpuFeatureNameFlashStage3d)
     return content::GPU_FEATURE_TYPE_FLASH_STAGE3D;
   else if (feature_string == kGpuFeatureNameTextureSharing)
     return content::GPU_FEATURE_TYPE_TEXTURE_SHARING;
+  else if (feature_string == kGpuFeatureNameAcceleratedVideoDecode)
+    return content::GPU_FEATURE_TYPE_ACCELERATED_VIDEO_DECODE;
   else if (feature_string == kGpuFeatureNameAll)
     return content::GPU_FEATURE_TYPE_ALL;
   return content::GPU_FEATURE_TYPE_UNKNOWN;
 }
 
 std::string GpuFeatureTypeToString(GpuFeatureType type) {
   std::vector<std::string> matches;
   if (type == content::GPU_FEATURE_TYPE_ALL) {
     matches.push_back(kGpuFeatureNameAll);
   } else {
@@ skipping 93 matching lines @@
           " 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

[Ami GONE FROM CHROMIUM, 2012/07/30 23:38:29]

Not sure what the "true" here means; if it means SW fallback is available, then
fine.  If it means that blacklist is applied by default, then no thank you :)

[Zhenyao Mo, 2012/07/30 23:40:10]

It means it falls back to SW path.

       }
   };
   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;
@@ skipping 230 matching lines @@
         kGpuBlacklistFeatureHistogramNamesWin[i],
         1, kNumWinSubVersions * kGpuFeatureNumStatus,
         kNumWinSubVersions * kGpuFeatureNumStatus + 1,
         base::Histogram::kUmaTargetedHistogramFlag);
     histogram_pointer->Add(GetGpuBlacklistHistogramValueWin(value));
 #endif
   }
 }
 
 }  // namespace gpu_util;