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

content/browser/compositor/gl_helper.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/compositor/gl_helper.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <queue>
@@ skipping 164 matching lines @@
                      ReadbackSwizzle swizzle,
                      const base::Callback<void(bool)>& callback);
 
   GLuint CopyAndScaleTexture(GLuint texture,
                              const gfx::Size& src_size,
                              const gfx::Size& dst_size,
                              bool vertically_flip_texture,
                              GLHelper::ScalerQuality quality);
 
   ReadbackYUVInterface* CreateReadbackPipelineYUV(
-      GLHelper::ScalerQuality quality,
       const gfx::Size& src_size,
       const gfx::Rect& src_subrect,
       const gfx::Size& dst_size,
       bool flip_vertically,
       bool use_mrt);
 
   // Returns the maximum number of draw buffers available,
   // 0 if GL_EXT_draw_buffers is not available.
   GLint MaxDrawBuffers() const { return max_draw_buffers_; }
 
@@ skipping 978 matching lines @@
   DCHECK(readback_support_.get());
   GLenum format, type;
   size_t bytes_per_pixel;
   FormatSupport support = readback_support_->GetReadbackConfig(
       color_type, false, &format, &type, &bytes_per_pixel);
 
   return (support == GLHelperReadbackSupport::SUPPORTED);
 }
 
 ReadbackYUVInterface* GLHelper::CopyTextureToImpl::CreateReadbackPipelineYUV(
-    GLHelper::ScalerQuality quality,
     const gfx::Size& src_size,
     const gfx::Rect& src_subrect,
     const gfx::Size& dst_size,
     bool flip_vertically,
     bool use_mrt) {
   helper_->InitScalerImpl();
   // Just query if the best readback configuration needs a swizzle In
   // ReadbackPlane() we will choose GL_RGBA/GL_BGRA_EXT based on swizzle
   GLenum format, type;
   size_t bytes_per_pixel;
   FormatSupport supported = GetReadbackConfig(kRGBA_8888_SkColorType, true,
                                               &format, &type, &bytes_per_pixel);
   DCHECK((format == GL_RGBA || format == GL_BGRA_EXT) &&
          type == GL_UNSIGNED_BYTE);
 
   ReadbackSwizzle swizzle = kSwizzleNone;
   if (supported == GLHelperReadbackSupport::SWIZZLE)
     swizzle = kSwizzleBGRA;
 
+  // "The YUV readback pipeline is used by real-time video capture of
+  // tabs/windows/desktops.  Therefore, the scaler chosen here is based on
+  // performance measurements of full end-to-end systems.  When down-scaling,
+  // always use the "fast" scaler because it performs well on both low- and
+  // high- end machines, provides decent image quality, and doesn't overwhelm
+  // downstream video encoders with too much entropy (which can drastically
+  // increase CPU utilization). When up-scaling, always use "best" because the
+  // quality improvement is huge with insignificant performance penalty.  Note
+  // that this strategy differs from single-frame snapshot capture (i.e., using
+  // the Skia/RGB code path).
+  GLHelper::ScalerQuality quality = ((src_size.width() < dst_size.width()) &&
+                                     (src_size.height() < dst_size.height()))
+                                        ? GLHelper::SCALER_QUALITY_BEST
+                                        : GLHelper::SCALER_QUALITY_FAST;

[piman, 2016/04/06 18:32:47]

If SCALER_QUALITY_GOOD is not used any more, can you remove the enum and the
related code?

[xjz, 2016/04/06 18:44:05]

SCALER_QUALITY_GOOD is used as the default scaler in single-frame snapshot
capture:
https://code.google.com/p/chromium/codesearch#chromium/src/content/browser/co....
It provides nearly as good quality as "best" down-scaler, but much faster in
general.

[piman, 2016/04/06 19:20:07]

If that the case, then can you leave the policy decision (this line) out of
GLHelper, and to the calling code instead? The only advantage of baking it in is
if it can remove code. Since it can't, let's leave it outside for consistency
with other readback API?

[xjz, 2016/04/06 23:03:38]

Done.

   if (max_draw_buffers_ >= 2 && use_mrt) {
     return new ReadbackYUV_MRT(gl_, this, helper_->scaler_impl_.get(), quality,
                                src_size, src_subrect, dst_size, flip_vertically,
                                swizzle);
   }
   return new ReadbackYUVImpl(gl_, this, helper_->scaler_impl_.get(), quality,
                              src_size, src_subrect, dst_size, flip_vertically,
                              swizzle);
 }
 
 ReadbackYUVInterface* GLHelper::CreateReadbackPipelineYUV(
-    ScalerQuality quality,
     const gfx::Size& src_size,
     const gfx::Rect& src_subrect,
     const gfx::Size& dst_size,
     bool flip_vertically,
     bool use_mrt) {
   InitCopyTextToImpl();
   return copy_texture_to_impl_->CreateReadbackPipelineYUV(
-      quality, src_size, src_subrect, dst_size, flip_vertically, use_mrt);
+      src_size, src_subrect, dst_size, flip_vertically, use_mrt);
 }
 
 }  // namespace content