Move components/display_compositor to components/viz/display_compositor

components/viz/display_compositor/gl_helper_unittest.cc

 // Copyright 2016 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 <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <string.h>
 #include <cmath>
 #include <string>
@@ skipping 12 matching lines @@
 #include "base/memory/ref_counted_memory.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/launcher/unit_test_launcher.h"
 #include "base/test/test_suite.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
-#include "components/display_compositor/gl_helper.h"
-#include "components/display_compositor/gl_helper_readback_support.h"
-#include "components/display_compositor/gl_helper_scaling.h"
+#include "components/viz/display_compositor/gl_helper.h"
+#include "components/viz/display_compositor/gl_helper_readback_support.h"
+#include "components/viz/display_compositor/gl_helper_scaling.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "gpu/command_buffer/client/shared_memory_limits.h"
 #include "gpu/ipc/gl_in_process_context.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkTypes.h"
 #include "ui/gl/gl_implementation.h"
 
-namespace display_compositor {
+namespace viz {
 
-display_compositor::GLHelper::ScalerQuality kQualities[] = {
-    display_compositor::GLHelper::SCALER_QUALITY_BEST,
-    display_compositor::GLHelper::SCALER_QUALITY_GOOD,
-    display_compositor::GLHelper::SCALER_QUALITY_FAST,
+GLHelper::ScalerQuality kQualities[] = {
+    GLHelper::SCALER_QUALITY_BEST, GLHelper::SCALER_QUALITY_GOOD,
+    GLHelper::SCALER_QUALITY_FAST,
 };
 
 const char* kQualityNames[] = {
     "best", "good", "fast",
 };
 
 class GLHelperTest : public testing::Test {
  protected:
   void SetUp() override {
     gpu::gles2::ContextCreationAttribHelper attributes;
@@ skipping 13 matching lines @@
                                         true,                    /* offscreen */
                                         gpu::kNullSurfaceHandle, /* window */
                                         nullptr, /* share_context */
                                         attributes, gpu::SharedMemoryLimits(),
                                         nullptr, /* gpu_memory_buffer_manager */
                                         nullptr, /* image_factory */
                                         base::ThreadTaskRunnerHandle::Get()));
     gl_ = context_->GetImplementation();
     gpu::ContextSupport* support = context_->GetImplementation();
 
-    helper_.reset(new display_compositor::GLHelper(gl_, support));
-    helper_scaling_.reset(
-        new display_compositor::GLHelperScaling(gl_, helper_.get()));
+    helper_.reset(new GLHelper(gl_, support));
+    helper_scaling_.reset(new GLHelperScaling(gl_, helper_.get()));
   }
 
   void TearDown() override {
     helper_scaling_.reset(nullptr);
     helper_.reset(nullptr);
     context_.reset(nullptr);
   }
 
   // Bicubic filter kernel function.
   static float Bicubic(float x) {
@@ skipping 136 matching lines @@
       // Multi-sample upscale-downscale combination?
       if (scale > samples / 2.0 && scale < samples) {
         return true;
       }
     }
     return false;
   }
 
   // Make sure that the stages of the scaler pipeline are sane.
   void ValidateScalerStages(
-      display_compositor::GLHelper::ScalerQuality quality,
+      GLHelper::ScalerQuality quality,
       const std::vector<GLHelperScaling::ScalerStage>& scaler_stages,
       const gfx::Size& dst_size,
       const std::string& message) {
     bool previous_error = HasFailure();
     // First, check that the input size for each stage is equal to
     // the output size of the previous stage.
     for (size_t i = 1; i < scaler_stages.size(); i++) {
       EXPECT_EQ(scaler_stages[i - 1].dst_size.width(),
                 scaler_stages[i].src_size.width());
       EXPECT_EQ(scaler_stages[i - 1].dst_size.height(),
@@ skipping 29 matching lines @@
 
       // Codify valid scale operations.
       switch (scaler_stages[i].shader) {
         case GLHelperScaling::SHADER_PLANAR:
         case GLHelperScaling::SHADER_YUV_MRT_PASS1:
         case GLHelperScaling::SHADER_YUV_MRT_PASS2:
           EXPECT_TRUE(false) << "Invalid shader.";
           break;
 
         case GLHelperScaling::SHADER_BILINEAR:
-          if (quality != display_compositor::GLHelper::SCALER_QUALITY_FAST) {
+          if (quality != GLHelper::SCALER_QUALITY_FAST) {
             x_samples = 1;
             y_samples = 1;
           }
           break;
         case GLHelperScaling::SHADER_BILINEAR2:
           x_samples = 2;
           y_samples = 1;
           break;
         case GLHelperScaling::SHADER_BILINEAR3:
           x_samples = 3;
@@ skipping 25 matching lines @@
             EXPECT_EQ(y_scale, 2.0);
           }
           break;
       }
 
       if (!scaler_stages[i].scale_x) {
         std::swap(x_samples, y_samples);
       }
 
       if (x_samples) {
-        EXPECT_TRUE(CheckScale(x_scale, x_samples, scaled_x)) << "x_scale = "
-                                                              << x_scale;
+        EXPECT_TRUE(CheckScale(x_scale, x_samples, scaled_x))
+            << "x_scale = " << x_scale;
       }
       if (y_samples) {
-        EXPECT_TRUE(CheckScale(y_scale, y_samples, scaled_y)) << "y_scale = "
-                                                              << y_scale;
+        EXPECT_TRUE(CheckScale(y_scale, y_samples, scaled_y))
+            << "y_scale = " << y_scale;
       }
 
       if (x_scale != 1.0) {
         scaled_x = true;
       }
       if (y_scale != 1.0) {
         scaled_y = true;
       }
     }
 
@@ skipping 23 matching lines @@
     EXPECT_TRUE(swizzle || truth->colorType() == other->colorType());
     int bpp = truth->bytesPerPixel();
     for (int x = 0; x < truth->width(); x++) {
       for (int y = 0; y < truth->height(); y++) {
         for (int c = 0; c < bpp; c++) {
           int a = Channel(truth, x, y, c);
           // swizzle when comparing if needed
           int b = swizzle && (c == 0 || c == 2)
                       ? Channel(other, x, y, (c + 2) & 2)
                       : Channel(other, x, y, c);
-          EXPECT_NEAR(a, b, maxdiff) << " x=" << x << " y=" << y << " c=" << c
-                                     << " " << message;
+          EXPECT_NEAR(a, b, maxdiff)
+              << " x=" << x << " y=" << y << " c=" << c << " " << message;
           if (std::abs(a - b) > maxdiff) {
             LOG(ERROR) << "-------expected--------";
             for (int i = 0; i < bpp; i++) {
               LOG(ERROR) << "Channel " << i << ":";
               PrintChannel(truth, i);
             }
             LOG(ERROR) << "-------actual--------";
             for (int i = 0; i < bpp; i++) {
               LOG(ERROR) << "Channel " << i << ":";
               PrintChannel(other, i);
@@ skipping 53 matching lines @@
                       c2 * kRGBtoGrayscaleColorWeights[2];
         SetChannel(output, dst_x, dst_y, 0,
                    static_cast<int>(value * 255.0f + 0.5f));
       }
     }
   }
 
   // Very slow bicubic / bilinear scaler for reference.
   void ScaleSlow(SkBitmap* input,
                  SkBitmap* output,
-                 display_compositor::GLHelper::ScalerQuality quality) {
+                 GLHelper::ScalerQuality quality) {
     float xscale = static_cast<float>(input->width()) / output->width();
     float yscale = static_cast<float>(input->height()) / output->height();
     float clamped_xscale = xscale < 1.0 ? 1.0 : 1.0 / xscale;
     float clamped_yscale = yscale < 1.0 ? 1.0 : 1.0 / yscale;
     for (int dst_y = 0; dst_y < output->height(); dst_y++) {
       for (int dst_x = 0; dst_x < output->width(); dst_x++) {
         for (int channel = 0; channel < 4; channel++) {
           float dst_x_in_src = (dst_x + 0.5f) * xscale;
           float dst_y_in_src = (dst_y + 0.5f) * yscale;
 
           float value = 0.0f;
           float sum = 0.0f;
           switch (quality) {
-            case display_compositor::GLHelper::SCALER_QUALITY_BEST:
+            case GLHelper::SCALER_QUALITY_BEST:
               for (int src_y = -10; src_y < input->height() + 10; ++src_y) {
                 float coeff_y =
                     Bicubic((src_y + 0.5f - dst_y_in_src) * clamped_yscale);
                 if (coeff_y == 0.0f) {
                   continue;
                 }
                 for (int src_x = -10; src_x < input->width() + 10; ++src_x) {
                   float coeff =
                       coeff_y *
                       Bicubic((src_x + 0.5f - dst_x_in_src) * clamped_xscale);
                   if (coeff == 0.0f) {
                     continue;
                   }
                   sum += coeff;
                   float c = ChannelAsFloat(input, src_x, src_y, channel);
                   value += c * coeff;
                 }
               }
               break;
 
-            case display_compositor::GLHelper::SCALER_QUALITY_GOOD: {
+            case GLHelper::SCALER_QUALITY_GOOD: {
               int xshift = 0, yshift = 0;
               while ((output->width() << xshift) < input->width()) {
                 xshift++;
               }
               while ((output->height() << yshift) < input->height()) {
                 yshift++;
               }
               int xmag = 1 << xshift;
               int ymag = 1 << yshift;
               if (xmag == 4 && output->width() * 3 >= input->width()) {
                 xmag = 3;
               }
               if (ymag == 4 && output->height() * 3 >= input->height()) {
                 ymag = 3;
               }
               for (int x = 0; x < xmag; x++) {
                 for (int y = 0; y < ymag; y++) {
                   value += Bilinear(
                       input, (dst_x * xmag + x + 0.5) * xscale / xmag,
                       (dst_y * ymag + y + 0.5) * yscale / ymag, channel);
                   sum += 1.0;
                 }
               }
               break;
             }
 
-            case display_compositor::GLHelper::SCALER_QUALITY_FAST:
+            case GLHelper::SCALER_QUALITY_FAST:
               value = Bilinear(input, dst_x_in_src, dst_y_in_src, channel);
               sum = 1.0;
           }
           value /= sum;
           SetChannel(output, dst_x, dst_y, channel,
                      static_cast<int>(value * 255.0f + 0.5f));
         }
       }
     }
   }
@@ skipping 11 matching lines @@
                              *bitmap->getAddr8(x, bottom_line));
       }
       top_line++;
       bottom_line--;
     }
   }
 
   // Swaps red and blue channels in each pixel in a 32-bit bitmap.
   void SwizzleSKBitmap(SkBitmap* bitmap) {
     int bpp = bitmap->bytesPerPixel();
-    DCHECK(bpp == 4);
+    DCHECK_EQ(bpp, 4);
     for (int y = 0; y < bitmap->height(); y++) {
       for (int x = 0; x < bitmap->width(); x++) {
         // Swap channels 0 and 2 (red and blue)
         int c0 = Channel(bitmap, x, y, 0);
         int c2 = Channel(bitmap, x, y, 2);
         SetChannel(bitmap, x, y, 2, c0);
         SetChannel(bitmap, x, y, 0, c2);
       }
     }
   }
 
   // gl_helper scales recursively, so we'll need to do that
   // in the reference implementation too.
   void ScaleSlowRecursive(SkBitmap* input,
                           SkBitmap* output,
-                          display_compositor::GLHelper::ScalerQuality quality) {
-    if (quality == display_compositor::GLHelper::SCALER_QUALITY_FAST ||
-        quality == display_compositor::GLHelper::SCALER_QUALITY_GOOD) {
+                          GLHelper::ScalerQuality quality) {
+    if (quality == GLHelper::SCALER_QUALITY_FAST ||
+        quality == GLHelper::SCALER_QUALITY_GOOD) {
       ScaleSlow(input, output, quality);
       return;
     }
 
     float xscale = static_cast<float>(output->width()) / input->width();
 
     // This corresponds to all the operations we can do directly.
     float yscale = static_cast<float>(output->height()) / input->height();
     if ((xscale == 1.0f && yscale == 1.0f) ||
         (xscale == 0.5f && yscale == 1.0f) ||
@@ skipping 248 matching lines @@
                          gfx::Size(dst_xsize, dst_ysize),
                          base::StringPrintf("input size: %dx%d "
                                             "output size: %dx%d "
                                             "quality: %s",
                                             xsize, ysize, dst_xsize, dst_ysize,
                                             kQualityNames[quality]));
   }
 
   // Create a scaling pipeline and make sure that the steps
   // are exactly the steps we expect.
-  void CheckPipeline(display_compositor::GLHelper::ScalerQuality quality,
+  void CheckPipeline(GLHelper::ScalerQuality quality,
                      int xsize,
                      int ysize,
                      int dst_xsize,
                      int dst_ysize,
                      const std::string& description) {
     std::vector<GLHelperScaling::ScalerStage> stages;
     helper_scaling_->ComputeScalerStages(
         quality, gfx::Size(xsize, ysize), gfx::Rect(0, 0, xsize, ysize),
         gfx::Size(dst_xsize, dst_ysize), false, false, &stages);
-    ValidateScalerStages(display_compositor::GLHelper::SCALER_QUALITY_GOOD,
-                         stages, gfx::Size(dst_xsize, dst_ysize), "");
+    ValidateScalerStages(GLHelper::SCALER_QUALITY_GOOD, stages,
+                         gfx::Size(dst_xsize, dst_ysize), "");
     EXPECT_EQ(PrintStages(stages), description);
   }
 
   static void callcallback(const base::Callback<void()>& callback,
                            bool result) {
     callback.Run();
   }
 
   void DrawGridToBitmap(int w,
                         int h,
                         SkColor background_color,
                         SkColor grid_color,
                         int grid_pitch,
                         int grid_width,
-                        SkBitmap& bmp) {
+                        const SkBitmap& bmp) {
     ASSERT_GT(grid_pitch, 0);
     ASSERT_GT(grid_width, 0);
     ASSERT_NE(background_color, grid_color);
 
     for (int y = 0; y < h; ++y) {
       bool y_on_grid = ((y % grid_pitch) < grid_width);
 
       for (int x = 0; x < w; ++x) {
         bool on_grid = (y_on_grid || ((x % grid_pitch) < grid_width));
 
         if (bmp.colorType() == kRGBA_8888_SkColorType ||
             bmp.colorType() == kBGRA_8888_SkColorType) {
           *bmp.getAddr32(x, y) = (on_grid ? grid_color : background_color);
         } else if (bmp.colorType() == kRGB_565_SkColorType) {
           *bmp.getAddr16(x, y) = (on_grid ? grid_color : background_color);
         }
       }
     }
   }
 
   void DrawCheckerToBitmap(int w,
                            int h,
                            SkColor color1,
                            SkColor color2,
                            int rect_w,
                            int rect_h,
-                           SkBitmap& bmp) {
+                           const SkBitmap& bmp) {
     ASSERT_GT(rect_w, 0);
     ASSERT_GT(rect_h, 0);
     ASSERT_NE(color1, color2);
 
     for (int y = 0; y < h; ++y) {
       bool y_bit = (((y / rect_h) & 0x1) == 0);
 
       for (int x = 0; x < w; ++x) {
         bool x_bit = (((x / rect_w) & 0x1) == 0);
 
@@ skipping 212 matching lines @@
     EXPECT_EQ(tmp, src);
   }
 
   void CheckPipeline2(int xsize,
                       int ysize,
                       int dst_xsize,
                       int dst_ysize,
                       const std::string& description) {
     std::vector<GLHelperScaling::ScalerStage> stages;
     helper_scaling_->ConvertScalerOpsToScalerStages(
-        display_compositor::GLHelper::SCALER_QUALITY_GOOD,
-        gfx::Size(xsize, ysize), gfx::Rect(0, 0, xsize, ysize),
-        gfx::Size(dst_xsize, dst_ysize), false, false, &x_ops_, &y_ops_,
-        &stages);
+        GLHelper::SCALER_QUALITY_GOOD, gfx::Size(xsize, ysize),
+        gfx::Rect(0, 0, xsize, ysize), gfx::Size(dst_xsize, dst_ysize), false,
+        false, &x_ops_, &y_ops_, &stages);
     EXPECT_EQ(x_ops_.size(), 0U);
     EXPECT_EQ(y_ops_.size(), 0U);
-    ValidateScalerStages(display_compositor::GLHelper::SCALER_QUALITY_GOOD,
-                         stages, gfx::Size(dst_xsize, dst_ysize), "");
+    ValidateScalerStages(GLHelper::SCALER_QUALITY_GOOD, stages,
+                         gfx::Size(dst_xsize, dst_ysize), "");
     EXPECT_EQ(PrintStages(stages), description);
   }
 
   void CheckOptimizationsTest() {
     // Basic upscale. X and Y should be combined into one pass.
     x_ops_.push_back(GLHelperScaling::ScaleOp(0, true, 2000));
     y_ops_.push_back(GLHelperScaling::ScaleOp(0, false, 2000));
     CheckPipeline2(1024, 768, 2000, 2000, "1024x768 -> 2000x2000 bilinear\n");
 
     // X scaled 1/2, Y upscaled, should still be one pass.
@@ skipping 102 matching lines @@
     CheckPipeline2(100, 100, 1, 1,
                    "100x100 -> 100x32 bilinear4 Y\n"
                    "100x32 -> 100x4 bilinear4 Y\n"
                    "100x4 -> 64x1 bilinear2x2\n"
                    "64x1 -> 8x1 bilinear4 X\n"
                    "8x1 -> 1x1 bilinear4 X\n");
   }
 
   std::unique_ptr<gpu::GLInProcessContext> context_;
   gpu::gles2::GLES2Interface* gl_;
-  std::unique_ptr<display_compositor::GLHelper> helper_;
-  std::unique_ptr<display_compositor::GLHelperScaling> helper_scaling_;
+  std::unique_ptr<GLHelper> helper_;
+  std::unique_ptr<GLHelperScaling> helper_scaling_;
   std::deque<GLHelperScaling::ScaleOp> x_ops_, y_ops_;
   base::MessageLoop message_loop_;
 };
 
 class GLHelperPixelTest : public GLHelperTest {
  private:
   gl::DisableNullDrawGLBindings enable_pixel_output_;
 };
 
 TEST_F(GLHelperTest, RGBASyncReadbackTest) {
@@ skipping 120 matching lines @@
         }
       }
     }
   }
 }
 
 // Make sure we don't create overly complicated pipelines
 // for a few common use cases.
 TEST_F(GLHelperTest, CheckSpecificPipelines) {
   // Upscale should be single pass.
-  CheckPipeline(display_compositor::GLHelper::SCALER_QUALITY_GOOD, 1024, 700,
-                1280, 720, "1024x700 -> 1280x720 bilinear\n");
+  CheckPipeline(GLHelper::SCALER_QUALITY_GOOD, 1024, 700, 1280, 720,
+                "1024x700 -> 1280x720 bilinear\n");
   // Slight downscale should use BILINEAR2X2.
-  CheckPipeline(display_compositor::GLHelper::SCALER_QUALITY_GOOD, 1280, 720,
-                1024, 700, "1280x720 -> 1024x700 bilinear2x2\n");
+  CheckPipeline(GLHelper::SCALER_QUALITY_GOOD, 1280, 720, 1024, 700,
+                "1280x720 -> 1024x700 bilinear2x2\n");
   // Most common tab capture pipeline on the Pixel.
   // Should be using two BILINEAR3 passes.
-  CheckPipeline(display_compositor::GLHelper::SCALER_QUALITY_GOOD, 2560, 1476,
-                1249, 720,
+  CheckPipeline(GLHelper::SCALER_QUALITY_GOOD, 2560, 1476, 1249, 720,
                 "2560x1476 -> 2560x720 bilinear3 Y\n"
                 "2560x720 -> 1249x720 bilinear3 X\n");
 }
 
 TEST_F(GLHelperTest, ScalerOpTest) {
   for (int allow3 = 0; allow3 <= 1; allow3++) {
     for (int dst = 1; dst < 2049; dst += 1 + (dst >> 3)) {
       for (int src = 1; src < 2049; src++) {
         TestAddOps(src, dst, allow3 == 1, (src & 1) == 1);
         if (HasFailure()) {
           LOG(ERROR) << "Failed for src=" << src << " dst=" << dst
                      << " allow3=" << allow3;
           return;
         }
       }
     }
   }
 }
 
 TEST_F(GLHelperTest, CheckOptimizations) {
   // Test in baseclass since it is friends with GLHelperScaling
   CheckOptimizationsTest();
 }
 
-}  // namespace display_compositor
+}  // namespace viz