cc: Add finch feature flag for checker-imaging.

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 <stddef.h>
 
 #include <memory>
 #include <utility>
@@ skipping 28 matching lines @@
   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 kNativeGpuMemoryBuffersFeatureName[] = "native_gpu_memory_buffers";
 const char kWebGL2FeatureName[] = "webgl2";
+const char kCheckerImagingFeatureName[] = "checker_imaging";
 
 const int kMinRasterThreads = 1;
 const int kMaxRasterThreads = 4;
 
 const int kMinMSAASampleCount = 0;
 
 struct GpuFeatureInfo {
   std::string name;
   bool blocked;
   bool disabled;
@@ skipping 80 matching lines @@
      false},
     {kNativeGpuMemoryBuffersFeatureName, false,
      !gpu::AreNativeGpuMemoryBuffersEnabled(),
      "Native GpuMemoryBuffers have been disabled, either via about:flags"
      " or command line.",
      true},
     {kWebGL2FeatureName,
      manager->IsFeatureBlacklisted(gpu::GPU_FEATURE_TYPE_WEBGL2),
      command_line.HasSwitch(switches::kDisableES3APIs),
      "WebGL2 has been disabled via blacklist or the command line.", false},
+    {kCheckerImagingFeatureName, false, !IsCheckerImagingEnabled(),
+     "Checker-imaging has been disabled via finch trial or the command line.",
+     false},
   };
   DCHECK(index < arraysize(kGpuFeatureInfo));
   *eof = (index == arraysize(kGpuFeatureInfo) - 1);
   return kGpuFeatureInfo[index];
 }
 
 }  // namespace
 
 int NumberOfRendererRasterThreads() {
   int num_processors = base::SysInfo::NumberOfProcessors();
@@ skipping 127 matching lines @@
 
   if (command_line.HasSwitch(cc::switches::kDisableMainFrameBeforeActivation))
     return false;
 
   if (command_line.HasSwitch(cc::switches::kEnableMainFrameBeforeActivation))
     return true;
 
   return true;
 }
 
+bool IsCheckerImagingEnabled() {
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+          cc::switches::kEnableCheckerImaging))
+    return true;
+
+  if (base::FeatureList::IsEnabled(features::kCheckerImaging))
+    return true;
+
+  return false;
+}
+
 base::DictionaryValue* GetFeatureStatus() {
   GpuDataManagerImpl* manager = GpuDataManagerImpl::GetInstance();
   std::string gpu_access_blocked_reason;
   bool gpu_access_blocked =
       !manager->GpuAccessAllowed(&gpu_access_blocked_reason);
 
   base::DictionaryValue* feature_status_dict = new base::DictionaryValue();
 
   bool eof = false;
   for (size_t i = 0; !eof; ++i) {
@@ skipping 22 matching lines @@
           status += "_force";
       }
       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 == kCheckerImagingFeatureName) {
+        const base::CommandLine& command_line =
+            *base::CommandLine::ForCurrentProcess();
+        if (command_line.HasSwitch(cc::switches::kEnableCheckerImaging))
+          status += "_force";
+        status += "_on";
+      }
     }
     if (gpu_feature_info.name == kWebGLFeatureName &&
         (gpu_feature_info.blocked || gpu_access_blocked) &&
         manager->ShouldUseSwiftShader()) {
       status = "unavailable_software";
     }
 
     feature_status_dict->SetString(gpu_feature_info.name, status);
   }
   return feature_status_dict;
@@ skipping 37 matching lines @@
     }
   }
   return problem_list;
 }
 
 std::vector<std::string> GetDriverBugWorkarounds() {
   return GpuDataManagerImpl::GetInstance()->GetDriverBugWorkarounds();
 }
 
 }  // namespace content