Adding a field trial for testing --force-compositing-mode on 50% of

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"
 #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/content_switches.h"
 #include "content/public/common/gpu_info.h"
 
+#if defined(OS_WIN)
+#include "base/win/windows_version.h"
+#elif defined(OS_MAC)
+#include "base/mac/mac_util.h"
+#endif
+
 using content::GpuDataManager;
 using content::GpuFeatureType;
 
 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";
@@ skipping 123 matching lines @@
       break;
   }
   return entry_index;
 }
 #endif  // OS_WIN
 
 }  // namespace
 
 namespace gpu_util {
 
+const char kForceCompositingModeFieldTrialName[] = "ForceCompositingMode";
+const char kFieldTrialEnabledName[] = "enabled";
+
+void InitializeForceCompositingModeFieldTrial() {
+// Enable the field trial only on desktop OS's.
+#if !(defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX))
+  return;
+#endif
+  chrome::VersionInfo::Channel channel = chrome::VersionInfo::GetChannel();
+  // Only run the trial on the Canary channel.
+  if (channel != chrome::VersionInfo::CHANNEL_CANARY)
+    return;
+#if defined(OS_WIN)
+  // Don't run the trial on Windows XP.
+  if (base::win::GetVersion() < base::win::VERSION_VISTA)
+    return;
+#elif defined(OS_MACOSX)
+  // Accelerated compositing is only implemented on Mac OSX 10.6 or later.
+  if (base::mac::IsOSLeopardOrEarlier())
+    return;
+#endif
+
+  const base::FieldTrial::Probability kDivisor = 100;
+  scoped_refptr<base::FieldTrial> trial(
+    base::FieldTrialList::FactoryGetFieldTrial(
+        kForceCompositingModeFieldTrialName, kDivisor,
+        "disable", 2012, 12, 31, NULL));
+
+  // Produce the same result on every run of this client.
+  trial->UseOneTimeRandomization();
+  // 50% probability of being in the enabled group.
+  const base::FieldTrial::Probability kEnableProbability = 50;
+  int enable_group = trial->AppendGroup(
+      kFieldTrialEnabledName, kEnableProbability);
+
+  bool enabled = (trial->group() == enable_group);
+  UMA_HISTOGRAM_BOOLEAN("GPU.InForceCompositingModeFieldTrial", enabled);
+}
+
+bool InForceCompositingModeTrial() {
+  base::FieldTrial* trial =
+      base::FieldTrialList::Find(kForceCompositingModeFieldTrialName);
+  if (!trial)
+    return false;
+  return trial->group_name() == kFieldTrialEnabledName;
+}
+
 GpuFeatureType StringToGpuFeatureType(const std::string& feature_string) {
   if (feature_string == kGpuFeatureNameAccelerated2dCanvas)
     return content::GPU_FEATURE_TYPE_ACCELERATED_2D_CANVAS;
   else if (feature_string == kGpuFeatureNameAcceleratedCompositing)
     return content::GPU_FEATURE_TYPE_ACCELERATED_COMPOSITING;
   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)
@@ skipping 107 matching lines @@
   {
     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)

[jar (doing other things), 2012/06/08 00:03:25]

nit: you could have made this an else if on line 347, and then avoided the more
complex indents on lines 348-351.

             status += "_software";
           else
             status += "_off";
         }
       } else if (GpuDataManager::GetInstance()->ShouldUseSoftwareRendering()) {
         status = "unavailable_software";
       } else if (kGpuFeatureInfo[i].blocked ||
                  gpu_access_blocked) {

[jar (doing other things), 2012/06/08 00:03:25]

nit: unwrap this line

         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 = CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kEnableThreadedCompositing) &&
             (!CommandLine::ForCurrentProcess()->HasSwitch(
                 switches::kDisableThreadedCompositing));
         if (kGpuFeatureInfo[i].name == "compositing" &&
-            CommandLine::ForCurrentProcess()->HasSwitch(
-                switches::kForceCompositingMode))
+            (CommandLine::ForCurrentProcess()->HasSwitch(
+                 switches::kForceCompositingMode) ||
+                 InForceCompositingModeTrial()))

[jar (doing other things), 2012/06/08 00:03:25]

nit: indent: It is hard to say how to fix this up.... but 373 and 374 shouldn't
be aligned IMO.  Better might be to indent 373 by 4 more spaces (two levels of
parens were entered).

These lines are hard to read, and would probably be better broken up:
 if (kGpuFeatureInfo[i].name == "compositing") {
    more ifs;
 } else if (kGpuFeatureInfo[i].name == "css_animation") { // line 379
    more ifs;
 }

It was also a little surprising that you checked for equality with "composting"
in two of these clauses (see line 376) which almost made me wonder if there was
a typo.

           status += "_force";
         if (kGpuFeatureInfo[i].name == "compositing" &&
             has_thread)
           status += "_threaded";
         if (kGpuFeatureInfo[i].name == "css_animation") {
           if (has_thread)
             status = "accelerated_threaded";
           else
             status = "accelerated";
         }
@@ skipping 180 matching lines @@
         kGpuBlacklistFeatureHistogramNamesWin[i],
         1, kNumWinSubVersions * kGpuFeatureNumStatus,
         kNumWinSubVersions * kGpuFeatureNumStatus + 1,
         base::Histogram::kUmaTargetedHistogramFlag);
     histogram_pointer->Add(GetGpuBlacklistHistogramValueWin(value));
 #endif
   }
 }
 
 }  // namespace gpu_util;