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;
 
+  // Tests show that the two up-scaling methods perform comparable speeds on the

[miu, 2016/03/29 20:08:52]

This comment should provide a little more context about the use case, and the
numbers are probably too much detail.  Suggest you replace this comment with:

"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), where "best"
is always preferred."

[xjz, 2016/03/29 21:14:50]

Yuri: Thanks for the suggestion. But do you want to change the default scaler
for single-frame snapshot capture path from "good" to "best"? It is "good" in
current code:
https://code.google.com/p/chromium/codesearch#chromium/src/content/browser/co....
As in the case of multiple parses down-scaling, "good" is almost as good as
"fast" in quality but is much faster, maybe just keep using "good" as the
default scaler for the single-frame capture path?

[miu, 2016/03/31 21:44:05]

Ah, no.  :)  Actually, we should just leave out that last part of the comment,
as discussed.

[xjz, 2016/03/31 23:03:39]

Done.

+  // tested machines. So we choose "best" up-scaling method by default to get
+  // the best quality.
+  // The three down-scaling methods perform close speeds on high end machines,
+  // but not on other machines. The "best" method could be up to 96% slower than
+  // the "good" one, and the "good" method 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 needed on
+  // low end machines, we choose the "fast" down-scaling method by default.
+  GLHelper::ScalerQuality quality = ((src_size.width() < dst_size.width()) &&

[miu, 2016/03/29 20:08:52]

Should this be:

  GLHelper::ScalerQuality quality = ((src_size.GetArea() < dst_size.GetArea())
      ? GLHelper::SCALER_QUALITY_BEST
      : GLHelper::SCALER_QUALITY_FAST;

[xjz, 2016/03/29 21:14:50]

The scaling is done in two separate dimensions. My intention was to use "best"
only when we need do upscaling in both dimensions. If using this condition check
on area, we may use "best" when one dimension is down-scaling, and results in a
performance penalty. 

[miu, 2016/03/31 21:44:05]

Sounds good.

+                                     (src_size.height() < dst_size.height()))
+                                        ? GLHelper::SCALER_QUALITY_BEST
+                                        : GLHelper::SCALER_QUALITY_FAST;
   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