Introduce components/display_compositor

components/display_compositor/gl_helper_unittest.cc

-// Copyright 2014 The Chromium Authors. All rights reserved.
+// 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>
 #include <vector>
@@ skipping 10 matching lines @@
 #include "base/macros.h"
 #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/time/time.h"
 #include "base/trace_event/trace_event.h"
-#include "content/browser/compositor/gl_helper.h"
-#include "content/browser/compositor/gl_helper_readback_support.h"
-#include "content/browser/compositor/gl_helper_scaling.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 "gpu/command_buffer/client/gl_in_process_context.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "gpu/command_buffer/client/shared_memory_limits.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 content {
+namespace display_compositor {
 
-content::GLHelper::ScalerQuality kQualities[] = {
-    content::GLHelper::SCALER_QUALITY_BEST,
-    content::GLHelper::SCALER_QUALITY_GOOD,
-    content::GLHelper::SCALER_QUALITY_FAST,
+display_compositor::GLHelper::ScalerQuality kQualities[] = {
+    display_compositor::GLHelper::SCALER_QUALITY_BEST,
+    display_compositor::GLHelper::SCALER_QUALITY_GOOD,
+    display_compositor::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 */
         gfx::kNullAcceleratedWidget, /* window */
         gfx::Size(1, 1),             /* size */
         nullptr,                     /* share_context */
         attributes, gfx::PreferDiscreteGpu, gpu::SharedMemoryLimits(),
         nullptr, /* gpu_memory_buffer_manager */
         nullptr /* image_factory */));
     gl_ = context_->GetImplementation();
     gpu::ContextSupport* support = context_->GetImplementation();
 
-    helper_.reset(new content::GLHelper(gl_, support));
-    helper_scaling_.reset(new content::GLHelperScaling(gl_, helper_.get()));
+    helper_.reset(new display_compositor::GLHelper(gl_, support));
+    helper_scaling_.reset(
+        new display_compositor::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(
-      content::GLHelper::ScalerQuality quality,
+      display_compositor::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 31 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 != content::GLHelper::SCALER_QUALITY_FAST) {
+          if (quality != display_compositor::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 149 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,
-                 content::GLHelper::ScalerQuality quality) {
+                 display_compositor::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 content::GLHelper::SCALER_QUALITY_BEST:
+            case display_compositor::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 content::GLHelper::SCALER_QUALITY_GOOD: {
+            case display_compositor::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 content::GLHelper::SCALER_QUALITY_FAST:
+            case display_compositor::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 27 matching lines @@
         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,
-                          content::GLHelper::ScalerQuality quality) {
-    if (quality == content::GLHelper::SCALER_QUALITY_FAST ||
-        quality == content::GLHelper::SCALER_QUALITY_GOOD) {
+                          display_compositor::GLHelper::ScalerQuality quality) {
+    if (quality == display_compositor::GLHelper::SCALER_QUALITY_FAST ||
+        quality == display_compositor::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 179 matching lines @@
                               xsize, ysize);
 
     std::string message = base::StringPrintf(
         "input size: %dx%d "
         "output size: %dx%d "
         "pattern: %d quality: %s",
         xsize, ysize, scaled_xsize, scaled_ysize, test_pattern,
         kQualityNames[quality_index]);
 
     std::vector<GLHelperScaling::ScalerStage> stages;
-    helper_scaling_->ComputeScalerStages(kQualities[quality_index],
-                                         gfx::Size(xsize, ysize),
-                                         gfx::Rect(0, 0, xsize, ysize),
-                                         gfx::Size(scaled_xsize, scaled_ysize),
-                                         flip,
-                                         false,
-                                         &stages);
-    ValidateScalerStages(kQualities[quality_index],
-                         stages,
-                         gfx::Size(scaled_xsize, scaled_ysize),
-                         message);
+    helper_scaling_->ComputeScalerStages(
+        kQualities[quality_index], gfx::Size(xsize, ysize),
+        gfx::Rect(0, 0, xsize, ysize), gfx::Size(scaled_xsize, scaled_ysize),
+        flip, false, &stages);
+    ValidateScalerStages(kQualities[quality_index], stages,
+                         gfx::Size(scaled_xsize, scaled_ysize), message);
 
     GLuint dst_texture = helper_->CopyAndScaleTexture(
         src_texture, gfx::Size(xsize, ysize),
         gfx::Size(scaled_xsize, scaled_ysize), flip, kQualities[quality_index]);
 
     SkBitmap output_pixels;
     output_pixels.allocPixels(SkImageInfo::Make(scaled_xsize, scaled_ysize,
                                                 kRGBA_8888_SkColorType,
                                                 kPremul_SkAlphaType));
 
@@ skipping 44 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(content::GLHelper::ScalerQuality quality,
+  void CheckPipeline(display_compositor::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(content::GLHelper::SCALER_QUALITY_GOOD, stages,
-                         gfx::Size(dst_xsize, dst_ysize), "");
+    ValidateScalerStages(display_compositor::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,
@@ skipping 125 matching lines @@
         break;
       case kRGBA_8888_SkColorType:
         format = GL_RGBA;
         break;
       case kRGB_565_SkColorType:
         format = GL_RGB;
         break;
       default:
         NOTREACHED();
     }
-    GLenum type = (color_type == kRGB_565_SkColorType) ?
-                  GL_UNSIGNED_SHORT_5_6_5 : GL_UNSIGNED_BYTE;
+    GLenum type = (color_type == kRGB_565_SkColorType) ? GL_UNSIGNED_SHORT_5_6_5
+                                                       : GL_UNSIGNED_BYTE;
     gl_->TexImage2D(GL_TEXTURE_2D, 0, format, src_size.width(),
                     src_size.height(), 0, format, type,
                     input_pixels.getPixels());
   }
 
   void ReadBackTexture(GLuint src_texture,
                        const gfx::Size& src_size,
                        unsigned char* pixels,
                        SkColorType color_type,
                        bool async) {
@@ skipping 109 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(
-        content::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);
+        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);
     EXPECT_EQ(x_ops_.size(), 0U);
     EXPECT_EQ(y_ops_.size(), 0U);
-    ValidateScalerStages(content::GLHelper::SCALER_QUALITY_GOOD, stages,
-                         gfx::Size(dst_xsize, dst_ysize), "");
+    ValidateScalerStages(display_compositor::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<content::GLHelper> helper_;
-  std::unique_ptr<content::GLHelperScaling> helper_scaling_;
+  std::unique_ptr<display_compositor::GLHelper> helper_;
+  std::unique_ptr<display_compositor::GLHelperScaling> helper_scaling_;
   std::deque<GLHelperScaling::ScaleOp> x_ops_, y_ops_;
 };
 
 class GLHelperPixelTest : public GLHelperTest {
  private:
   gfx::DisableNullDrawGLBindings enable_pixel_output_;
 };
 
 TEST_F(GLHelperTest, RGBASyncReadbackTest) {
   const int kTestSize = 64;
@@ skipping 119 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(content::GLHelper::SCALER_QUALITY_GOOD, 1024, 700, 1280, 720,
-                "1024x700 -> 1280x720 bilinear\n");
+  CheckPipeline(display_compositor::GLHelper::SCALER_QUALITY_GOOD, 1024, 700,
+                1280, 720, "1024x700 -> 1280x720 bilinear\n");
   // Slight downscale should use BILINEAR2X2.
-  CheckPipeline(content::GLHelper::SCALER_QUALITY_GOOD, 1280, 720, 1024, 700,
-                "1280x720 -> 1024x700 bilinear2x2\n");
+  CheckPipeline(display_compositor::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(content::GLHelper::SCALER_QUALITY_GOOD, 2560, 1476, 1249, 720,
+  CheckPipeline(display_compositor::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 content
+}  // namespace display_compositor