Remove --tab-capture-upscale/downscale-quality.

chrome/browser/extensions/api/tab_capture/tab_capture_performancetest.cc

 // Copyright 2013 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 "base/command_line.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/trace_event_analyzer.h"
 #include "base/win/windows_version.h"
 #include "chrome/browser/extensions/extension_apitest.h"
 #include "chrome/browser/extensions/extension_service.h"
@@ skipping 23 matching lines @@
 
 enum TestFlags {
   kUseGpu              = 1 << 0, // Only execute test if --enable-gpu was given
                                  // on the command line.  This is required for
                                  // tests that run on GPU.
   kForceGpuComposited  = 1 << 1, // Force the test to use the compositor.
   kDisableVsync        = 1 << 2, // Do not limit framerate to vertical refresh.
                                  // when on GPU, nor to 60hz when not on GPU.
   kTestThroughWebRTC   = 1 << 3, // Send captured frames through webrtc
   kSmallWindow         = 1 << 4, // 1 = 800x600, 0 = 2000x1000
-
-  kScaleQualityMask    = 3 << 5, // two bits select which scaling quality
-  kScaleQualityDefault = 0 << 5, // to use on aura.
-  kScaleQualityFast    = 1 << 5,
-  kScaleQualityGood    = 2 << 5,
-  kScaleQualityBest    = 3 << 5,
 };
 
 class TabCapturePerformanceTest
     : public ExtensionApiTest,
       public testing::WithParamInterface<int> {
  public:
   TabCapturePerformanceTest() {}
 
   bool HasFlag(TestFlags flag) const {
     return (GetParam() & flag) == flag;
   }
 
   bool IsGpuAvailable() const {
     return base::CommandLine::ForCurrentProcess()->HasSwitch("enable-gpu");
   }
 
-  std::string ScalingMethod() const {
-    switch (GetParam() & kScaleQualityMask) {
-      case kScaleQualityFast:
-        return "fast";
-      case kScaleQualityGood:
-        return "good";
-      case kScaleQualityBest:
-        return "best";
-      default:
-        return "";
-    }
-  }
-
   std::string GetSuffixForTestFlags() {
     std::string suffix;
     if (HasFlag(kForceGpuComposited))
       suffix += "_comp";
     if (HasFlag(kUseGpu))
       suffix += "_gpu";
     if (HasFlag(kDisableVsync))
       suffix += "_novsync";
     if (HasFlag(kTestThroughWebRTC))
       suffix += "_webrtc";
-    if (!ScalingMethod().empty())
-      suffix += "_scale" + ScalingMethod();
     if (HasFlag(kSmallWindow))
       suffix += "_small";
     return suffix;
   }
 
   void SetUp() override {
     EnablePixelOutput();
     ExtensionApiTest::SetUp();
   }
 
   void SetUpCommandLine(base::CommandLine* command_line) override {
-    if (!ScalingMethod().empty()) {
-      command_line->AppendSwitchASCII(switches::kTabCaptureUpscaleQuality,
-                                      ScalingMethod());
-      command_line->AppendSwitchASCII(switches::kTabCaptureDownscaleQuality,
-                                      ScalingMethod());
-    }
-
     // Some of the tests may launch http requests through JSON or AJAX
     // which causes a security error (cross domain request) when the page
     // is loaded from the local file system ( file:// ). The following switch
     // fixes that error.
     command_line->AppendSwitch(switches::kAllowFileAccessFromFiles);
 
     if (HasFlag(kSmallWindow)) {
       command_line->AppendSwitchASCII(switches::kWindowSize, "800,600");
     } else {
       command_line->AppendSwitchASCII(switches::kWindowSize, "2000,1500");
@@ skipping 113 matching lines @@
     testing::Values(
         0,
         kUseGpu | kForceGpuComposited,
         kDisableVsync,
         kDisableVsync | kUseGpu | kForceGpuComposited,
         kTestThroughWebRTC,
         kTestThroughWebRTC | kUseGpu | kForceGpuComposited,
         kTestThroughWebRTC | kDisableVsync,
         kTestThroughWebRTC | kDisableVsync | kUseGpu | kForceGpuComposited));
 
 #if defined(USE_AURA)

[miu, 2016/02/19 01:47:59]

I think you'll want to remove all the code from here to the end of the file too.

But...perhaps you should run these on a few of the lab machines and your desktop
to determine relative performance first?  One thing that's been bothering me is
that we don't have numbers that say, "Good is X% slower than Fast" and "Best is
Y% slower than Fast."  And also, downscaling versus upscaling.

[xjz, 2016/03/28 19:52:15]

Done.

Did a bunch of tests on several lab machines and also on my own desktops. 
Results show that the speeds of the three scaling methods are quite close on
high end machines, but not on other machines. The "best" down-scaling could be
up to 96% slower than the "good" one, and the "good" one could be up to 250%
slower than the "fast" one. As we don't have criteria to determine the proper
scaling method in flight, and generally the down-scaling is more often to be
done on low end machines, we choose "fast" down-scaling method by default. The
two "upscaling" methods perform comparable speed on different machines, so we
choose "best" scaling method as the default method for upscaling. Also added the
comment in the code.

 // TODO(hubbe):
 // These are temporary tests for the purpose of determining what the
 // appropriate scaling quality is. Once that has been determined,
 // these tests will be removed.
 
 const int kScalingTestBase =
     kTestThroughWebRTC | kDisableVsync | kUseGpu | kForceGpuComposited;
 
 INSTANTIATE_TEST_CASE_P(
     ScalingTests,
     TabCapturePerformanceTest,
     testing::Values(
         kScalingTestBase | kScaleQualityFast,
         kScalingTestBase | kScaleQualityGood,
         kScalingTestBase | kScaleQualityBest,
         kScalingTestBase | kScaleQualityFast | kSmallWindow,
         kScalingTestBase | kScaleQualityGood | kSmallWindow,
         kScalingTestBase | kScaleQualityBest | kSmallWindow));
 
 #endif  // USE_AURA