GLHelper: validate destination size matches last scale size in test

content/common/gpu/client/gl_helper_unittest.cc

 // Copyright 2014 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 <stdio.h>
 #include <cmath>
 #include <string>
 #include <vector>
 
 #include <GLES2/gl2.h>
@@ skipping 240 matching lines @@
         return true;
       }
     }
     return false;
   }
 
   // Make sure that the stages of the scaler pipeline are sane.
   void ValidateScalerStages(
       content::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(),
                 scaler_stages[i].src_size.height());
       EXPECT_EQ(scaler_stages[i].src_subrect.x(), 0);
       EXPECT_EQ(scaler_stages[i].src_subrect.y(), 0);
       EXPECT_EQ(scaler_stages[i].src_subrect.width(),
                 scaler_stages[i].src_size.width());
       EXPECT_EQ(scaler_stages[i].src_subrect.height(),
                 scaler_stages[i].src_size.height());
     }
 
+    // Check the output size matches the destination of the last stage
+    EXPECT_EQ(scaler_stages[scaler_stages.size() - 1].dst_size.width(),
+              dst_size.width());
+    EXPECT_EQ(scaler_stages[scaler_stages.size() - 1].dst_size.height(),
+              dst_size.height());
+
     // Used to verify that up-scales are not attempted after some
     // other scale.
     bool scaled_x = false;
     bool scaled_y = false;
 
     for (size_t i = 0; i < scaler_stages.size(); i++) {
       // Note: 2.0 means scaling down by 50%
       double x_scale =
           static_cast<double>(scaler_stages[i].src_subrect.width()) /
           static_cast<double>(scaler_stages[i].dst_size.width());
@@ skipping 342 matching lines @@
         kQualityNames[quality]);
 
     std::vector<GLHelperScaling::ScalerStage> stages;
     helper_scaling_->ComputeScalerStages(kQualities[quality],
                                          gfx::Size(xsize, ysize),
                                          gfx::Rect(0, 0, xsize, ysize),
                                          gfx::Size(scaled_xsize, scaled_ysize),
                                          flip,
                                          false,
                                          &stages);
-    ValidateScalerStages(kQualities[quality], stages, message);
+    ValidateScalerStages(kQualities[quality],
+                         stages,
+                         gfx::Size(scaled_xsize, scaled_ysize),
+                         message);
 
     WebGLId dst_texture =
         helper_->CopyAndScaleTexture(src_texture,
                                      gfx::Size(xsize, ysize),
                                      gfx::Size(scaled_xsize, scaled_ysize),
                                      flip,
                                      kQualities[quality]);
 
     SkBitmap output_pixels;
     output_pixels.allocN32Pixels(scaled_xsize, scaled_ysize);
@@ skipping 41 matching lines @@
     std::vector<GLHelperScaling::ScalerStage> stages;
     helper_scaling_->ComputeScalerStages(kQualities[quality],
                                          gfx::Size(xsize, ysize),
                                          gfx::Rect(0, 0, xsize, ysize),
                                          gfx::Size(dst_xsize, dst_ysize),
                                          false,
                                          false,
                                          &stages);
     ValidateScalerStages(kQualities[quality],
                          stages,
+                         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,
                      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, "");
+    ValidateScalerStages(content::GLHelper::SCALER_QUALITY_GOOD,
+                         stages,
+                         gfx::Size(dst_xsize, dst_ysize),
+                         "");
     EXPECT_EQ(PrintStages(stages), description);
   }
 
   // Note: Left/Right means Top/Bottom when used for Y dimension.
   enum Margin {
     MarginLeft,
     MarginMiddle,
     MarginRight,
     MarginInvalid,
   };
@@ skipping 538 matching lines @@
         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, "");
+    ValidateScalerStages(content::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.
     x_ops_.push_back(GLHelperScaling::ScaleOp(2, true, 512));
     y_ops_.push_back(GLHelperScaling::ScaleOp(0, false, 2000));
     CheckPipeline2(1024, 768, 512, 2000, "1024x768 -> 512x2000 bilinear\n");
 
     // X upscaled, Y scaled 1/2, one bilinear pass
     x_ops_.push_back(GLHelperScaling::ScaleOp(0, true, 2000));
     y_ops_.push_back(GLHelperScaling::ScaleOp(2, false, 384));
     CheckPipeline2(1024, 768, 2000, 384, "1024x768 -> 2000x384 bilinear\n");
 
     // X scaled 1/2, Y scaled 1/2, one bilinear pass
     x_ops_.push_back(GLHelperScaling::ScaleOp(2, true, 512));
     y_ops_.push_back(GLHelperScaling::ScaleOp(2, false, 384));
-    CheckPipeline2(1024, 768, 2000, 384, "1024x768 -> 512x384 bilinear\n");
+    CheckPipeline2(1024, 768, 512, 384, "1024x768 -> 512x384 bilinear\n");
 
     // X scaled 1/2, Y scaled to 60%, one bilinear2 pass.
     x_ops_.push_back(GLHelperScaling::ScaleOp(2, true, 50));
     y_ops_.push_back(GLHelperScaling::ScaleOp(0, false, 120));
     y_ops_.push_back(GLHelperScaling::ScaleOp(2, false, 60));
     CheckPipeline2(100, 100, 50, 60, "100x100 -> 50x60 bilinear2 Y\n");
 
     // X scaled to 60%, Y scaled 1/2, one bilinear2 pass.
     x_ops_.push_back(GLHelperScaling::ScaleOp(0, true, 120));
     x_ops_.push_back(GLHelperScaling::ScaleOp(2, true, 60));
     y_ops_.push_back(GLHelperScaling::ScaleOp(2, false, 50));
-    CheckPipeline2(100, 100, 50, 60, "100x100 -> 60x50 bilinear2 X\n");
+    CheckPipeline2(100, 100, 60, 50, "100x100 -> 60x50 bilinear2 X\n");
 
     // X scaled to 60%, Y scaled 60%, one bilinear2x2 pass.
     x_ops_.push_back(GLHelperScaling::ScaleOp(0, true, 120));
     x_ops_.push_back(GLHelperScaling::ScaleOp(2, true, 60));
     y_ops_.push_back(GLHelperScaling::ScaleOp(0, false, 120));
     y_ops_.push_back(GLHelperScaling::ScaleOp(2, false, 60));
     CheckPipeline2(100, 100, 60, 60, "100x100 -> 60x60 bilinear2x2\n");
 
     // X scaled to 40%, Y scaled 40%, two bilinear3 passes.
     x_ops_.push_back(GLHelperScaling::ScaleOp(3, true, 40));
@@ skipping 74 matching lines @@
     y_ops_.push_back(GLHelperScaling::ScaleOp(0, false, 128));
     y_ops_.push_back(GLHelperScaling::ScaleOp(2, false, 64));
     y_ops_.push_back(GLHelperScaling::ScaleOp(2, false, 32));
     y_ops_.push_back(GLHelperScaling::ScaleOp(2, false, 16));
     y_ops_.push_back(GLHelperScaling::ScaleOp(2, false, 8));
     y_ops_.push_back(GLHelperScaling::ScaleOp(2, false, 4));
     y_ops_.push_back(GLHelperScaling::ScaleOp(2, false, 2));
     y_ops_.push_back(GLHelperScaling::ScaleOp(2, false, 1));
     CheckPipeline2(100,
                    100,
-                   30,
-                   30,
+                   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");
   }
 
   scoped_ptr<WebGraphicsContext3DInProcessCommandBufferImpl> context_;
   gpu::ContextSupport* context_support_;
   scoped_ptr<content::GLHelper> helper_;
@@ skipping 221 matching lines @@
   CommandLine::Init(argc, argv);
   base::TestSuite* suite = new content::ContentTestSuite(argc, argv);
 #if defined(OS_MACOSX)
   base::mac::ScopedNSAutoreleasePool pool;
 #endif
 
   content::UnitTestTestSuite runner(suite);
   base::MessageLoop message_loop;
   return runner.Run();
 }