Move gl_helper to content/browser/compositor

content/browser/compositor/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 <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <string.h>
 #include <cmath>
 #include <string>
@@ skipping 11 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/common/gpu/client/gl_helper.h"
-#include "content/common/gpu/client/gl_helper_readback_support.h"
-#include "content/common/gpu/client/gl_helper_scaling.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 "gpu/command_buffer/client/gl_in_process_context.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "media/base/video_frame.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 {
 
 content::GLHelper::ScalerQuality kQualities[] = {
     content::GLHelper::SCALER_QUALITY_BEST,
     content::GLHelper::SCALER_QUALITY_GOOD,
-    content::GLHelper::SCALER_QUALITY_FAST, };
+    content::GLHelper::SCALER_QUALITY_FAST,
+};
 
-const char* kQualityNames[] = {"best", "good", "fast", };
+const char* kQualityNames[] = {
+    "best", "good", "fast",
+};
 
 class GLHelperTest : public testing::Test {
  protected:
   void SetUp() override {
     gpu::gles2::ContextCreationAttribHelper attributes;
     attributes.alpha_size = 8;
     attributes.depth_size = 24;
     attributes.red_size = 8;
     attributes.green_size = 8;
     attributes.blue_size = 8;
@@ skipping 48 matching lines @@
     }
   }
 
   // End tracing, return tracing data in a simple map
   // of event name->counts.
   void EndTracing(std::map<std::string, int>* event_counts) {
     std::string json_data = "[";
     base::trace_event::TraceLog::GetInstance()->SetDisabled();
     base::RunLoop run_loop;
     base::trace_event::TraceLog::GetInstance()->Flush(
-        base::Bind(&GLHelperTest::TraceDataCB,
-                   run_loop.QuitClosure(),
+        base::Bind(&GLHelperTest::TraceDataCB, run_loop.QuitClosure(),
                    base::Unretained(&json_data)));
     run_loop.Run();
     json_data.append("]");
 
     std::string error_msg;
     scoped_ptr<base::Value> trace_data =
         base::JSONReader::ReadAndReturnError(json_data, 0, NULL, &error_msg);
-    CHECK(trace_data)
-        << "JSON parsing failed (" << error_msg << ") JSON data:" << std::endl
-        << json_data;
+    CHECK(trace_data) << "JSON parsing failed (" << error_msg
+                      << ") JSON data:" << std::endl
+                      << json_data;
 
     base::ListValue* list;
     CHECK(trace_data->GetAsList(&list));
     for (size_t i = 0; i < list->GetSize(); i++) {
       base::Value* item = NULL;
       if (list->Get(i, &item)) {
         base::DictionaryValue* dict;
         CHECK(item->GetAsDictionary(&dict));
         std::string name;
         CHECK(dict->GetString("name", &name));
@@ skipping 68 matching lines @@
       }
       LOG(ERROR) << formatted;
     }
   }
 
   // Print out the individual steps of a scaler pipeline.
   std::string PrintStages(
       const std::vector<GLHelperScaling::ScalerStage>& scaler_stages) {
     std::string ret;
     for (size_t i = 0; i < scaler_stages.size(); i++) {
-      ret.append(base::StringPrintf("%dx%d -> %dx%d ",
-                                    scaler_stages[i].src_size.width(),
-                                    scaler_stages[i].src_size.height(),
-                                    scaler_stages[i].dst_size.width(),
-                                    scaler_stages[i].dst_size.height()));
+      ret.append(base::StringPrintf(
+          "%dx%d -> %dx%d ", scaler_stages[i].src_size.width(),
+          scaler_stages[i].src_size.height(), scaler_stages[i].dst_size.width(),
+          scaler_stages[i].dst_size.height()));
       bool xy_matters = false;
       switch (scaler_stages[i].shader) {
         case GLHelperScaling::SHADER_BILINEAR:
           ret.append("bilinear");
           break;
         case GLHelperScaling::SHADER_BILINEAR2:
           ret.append("bilinear2");
           xy_matters = true;
           break;
         case GLHelperScaling::SHADER_BILINEAR3:
@@ skipping 154 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 89 matching lines @@
     CHECK_EQ(input->colorType(), kRGBA_8888_SkColorType);
 
     for (int dst_y = 0; dst_y < output->height(); dst_y++) {
       for (int dst_x = 0; dst_x < output->width(); dst_x++) {
         float c0 = ChannelAsFloat(input, dst_x, dst_y, 0);
         float c1 = ChannelAsFloat(input, dst_x, dst_y, 1);
         float c2 = ChannelAsFloat(input, dst_x, dst_y, 2);
         float value = c0 * kRGBtoGrayscaleColorWeights[0] +
                       c1 * kRGBtoGrayscaleColorWeights[1] +
                       c2 * kRGBtoGrayscaleColorWeights[2];
-        SetChannel(
-            output, dst_x, dst_y, 0, static_cast<int>(value * 255.0f + 0.5f));
+        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) {
     float xscale = static_cast<float>(input->width()) / output->width();
     float yscale = static_cast<float>(input->height()) / output->height();
@@ skipping 40 matching lines @@
               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);
+                  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:
               value = Bilinear(input, dst_x_in_src, dst_y_in_src, channel);
               sum = 1.0;
           }
           value /= sum;
-          SetChannel(output,
-                     dst_x,
-                     dst_y,
-                     channel,
+          SetChannel(output, dst_x, dst_y, channel,
                      static_cast<int>(value * 255.0f + 0.5f));
         }
       }
     }
   }
 
   void FlipSKBitmap(SkBitmap* bitmap) {
     int bpp = bitmap->bytesPerPixel();
     DCHECK(bpp == 4 || bpp == 1);
     int top_line = 0;
@@ skipping 71 matching lines @@
 
     ScaleSlowRecursive(input, &tmp, quality);
     ScaleSlowRecursive(&tmp, output, quality);
   }
 
   // Creates an RGBA SkBitmap
   scoped_ptr<SkBitmap> CreateTestBitmap(int width,
                                         int height,
                                         int test_pattern) {
     scoped_ptr<SkBitmap> bitmap(new SkBitmap);
-    bitmap->allocPixels(SkImageInfo::Make(
-        width, height, kRGBA_8888_SkColorType, kPremul_SkAlphaType));
+    bitmap->allocPixels(SkImageInfo::Make(width, height, kRGBA_8888_SkColorType,
+                                          kPremul_SkAlphaType));
 
     for (int x = 0; x < width; ++x) {
       for (int y = 0; y < height; ++y) {
         switch (test_pattern) {
           case 0:  // Smooth test pattern
             SetChannel(bitmap.get(), x, y, 0, x * 10);
             SetChannel(bitmap.get(), x, y, 0, y == 0 ? x * 50 : x * 10);
             SetChannel(bitmap.get(), x, y, 1, y * 10);
             SetChannel(bitmap.get(), x, y, 2, (x + y) * 10);
             SetChannel(bitmap.get(), x, y, 3, 255);
@@ skipping 41 matching lines @@
                                             size_t quality_index) {
     DCHECK(out_color_type == kAlpha_8_SkColorType ||
            out_color_type == kRGBA_8888_SkColorType ||
            out_color_type == kBGRA_8888_SkColorType);
     GLuint src_texture;
     gl_->GenTextures(1, &src_texture);
     GLuint framebuffer;
     gl_->GenFramebuffers(1, &framebuffer);
     scoped_ptr<SkBitmap> input_pixels =
         CreateTestBitmap(xsize, ysize, test_pattern);
-    BindTextureAndFrameBuffer(
-        src_texture, framebuffer, input_pixels.get(), xsize, ysize);
+    BindTextureAndFrameBuffer(src_texture, framebuffer, input_pixels.get(),
+                              xsize, ysize);
 
     std::string message = base::StringPrintf(
         "input size: %dx%d "
         "output size: %dx%d "
         "pattern: %d , quality: %s, "
         "out_color_type: %d",
-        xsize,
-        ysize,
-        scaled_xsize,
-        scaled_ysize,
-        test_pattern,
-        kQualityNames[quality_index],
-        out_color_type);
+        xsize, ysize, scaled_xsize, scaled_ysize, test_pattern,
+        kQualityNames[quality_index], out_color_type);
 
     // Transform the bitmap using GLHelper::CropScaleReadbackAndCleanTexture.
     SkBitmap output_pixels;
     output_pixels.allocPixels(SkImageInfo::Make(
         scaled_xsize, scaled_ysize, out_color_type, kPremul_SkAlphaType));
     base::RunLoop run_loop;
     gfx::Size encoded_texture_size;
     helper_->CropScaleReadbackAndCleanTexture(
-        src_texture,
-        gfx::Size(xsize, ysize),
-        gfx::Rect(xsize, ysize),
+        src_texture, gfx::Size(xsize, ysize), gfx::Rect(xsize, ysize),
         gfx::Size(scaled_xsize, scaled_ysize),
-        static_cast<unsigned char*>(output_pixels.getPixels()),
-        out_color_type,
+        static_cast<unsigned char*>(output_pixels.getPixels()), out_color_type,
         base::Bind(&callcallback, run_loop.QuitClosure()),
         kQualities[quality_index]);
     run_loop.Run();
     // CropScaleReadbackAndCleanTexture flips the pixels. Flip them back.
     FlipSKBitmap(&output_pixels);
 
     // If the bitmap shouldn't have changed - compare against input.
     if (xsize == scaled_xsize && ysize == scaled_ysize &&
         out_color_type != kAlpha_8_SkColorType) {
       const std::vector<GLHelperScaling::ScalerStage> dummy_stages;
-      Compare(input_pixels.get(),
-              &output_pixels,
-              0,
-              NULL,
-              dummy_stages,
+      Compare(input_pixels.get(), &output_pixels, 0, NULL, dummy_stages,
               message + " comparing against input");
       return;
     }
 
     // Now transform the bitmap using the reference implementation.
     SkBitmap scaled_pixels;
-    scaled_pixels.allocPixels(SkImageInfo::Make(scaled_xsize,
-                                                scaled_ysize,
+    scaled_pixels.allocPixels(SkImageInfo::Make(scaled_xsize, scaled_ysize,
                                                 kRGBA_8888_SkColorType,
                                                 kPremul_SkAlphaType));
     SkBitmap truth_pixels;
     // Step 1: Scale
-    ScaleSlowRecursive(
-        input_pixels.get(), &scaled_pixels, kQualities[quality_index]);
+    ScaleSlowRecursive(input_pixels.get(), &scaled_pixels,
+                       kQualities[quality_index]);
     // Step 2: Encode to grayscale if needed.
     if (out_color_type == kAlpha_8_SkColorType) {
       truth_pixels.allocPixels(SkImageInfo::Make(
           scaled_xsize, scaled_ysize, out_color_type, kPremul_SkAlphaType));
       EncodeToGrayscaleSlow(&scaled_pixels, &truth_pixels);
     } else {
       truth_pixels = scaled_pixels;
     }
 
     // Now compare the results.
     SkAutoLockPixels lock_input(truth_pixels);
     const std::vector<GLHelperScaling::ScalerStage> dummy_stages;
-    Compare(&truth_pixels,
-            &output_pixels,
-            2,
-            input_pixels.get(),
-            dummy_stages,
+    Compare(&truth_pixels, &output_pixels, 2, input_pixels.get(), dummy_stages,
             message + " comparing against transformed/scaled");
 
     gl_->DeleteTextures(1, &src_texture);
     gl_->DeleteFramebuffers(1, &framebuffer);
   }
 
   // Scaling test: Create a test image, scale it using GLHelperScaling
   // and a reference implementation and compare the results.
   void TestScale(int xsize,
                  int ysize,
                  int scaled_xsize,
                  int scaled_ysize,
                  int test_pattern,
                  size_t quality_index,
                  bool flip) {
     GLuint src_texture;
     gl_->GenTextures(1, &src_texture);
     GLuint framebuffer;
     gl_->GenFramebuffers(1, &framebuffer);
     scoped_ptr<SkBitmap> input_pixels =
         CreateTestBitmap(xsize, ysize, test_pattern);
-    BindTextureAndFrameBuffer(
-        src_texture, framebuffer, input_pixels.get(), xsize, ysize);
+    BindTextureAndFrameBuffer(src_texture, framebuffer, input_pixels.get(),
+                              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,
+        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);
 
     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,
+    output_pixels.allocPixels(SkImageInfo::Make(scaled_xsize, scaled_ysize,
                                                 kRGBA_8888_SkColorType,
                                                 kPremul_SkAlphaType));
 
     helper_->ReadbackTextureSync(
-        dst_texture,
-        gfx::Rect(0, 0, scaled_xsize, scaled_ysize),
+        dst_texture, gfx::Rect(0, 0, scaled_xsize, scaled_ysize),
         static_cast<unsigned char*>(output_pixels.getPixels()),
         kRGBA_8888_SkColorType);
     if (flip) {
       // Flip the pixels back.
       FlipSKBitmap(&output_pixels);
     }
 
     // If the bitmap shouldn't have changed - compare against input.
     if (xsize == scaled_xsize && ysize == scaled_ysize) {
-      Compare(input_pixels.get(),
-              &output_pixels,
-              0,
-              NULL,
-              stages,
+      Compare(input_pixels.get(), &output_pixels, 0, NULL, stages,
               message + " comparing against input");
       return;
     }
 
     // Now scale the bitmap using the reference implementation.
     SkBitmap truth_pixels;
-    truth_pixels.allocPixels(SkImageInfo::Make(scaled_xsize,
-                                               scaled_ysize,
+    truth_pixels.allocPixels(SkImageInfo::Make(scaled_xsize, scaled_ysize,
                                                kRGBA_8888_SkColorType,
                                                kPremul_SkAlphaType));
-    ScaleSlowRecursive(
-        input_pixels.get(), &truth_pixels, kQualities[quality_index]);
-    Compare(&truth_pixels,
-            &output_pixels,
-            2,
-            input_pixels.get(),
-            stages,
+    ScaleSlowRecursive(input_pixels.get(), &truth_pixels,
+                       kQualities[quality_index]);
+    Compare(&truth_pixels, &output_pixels, 2, input_pixels.get(), stages,
             message + " comparing against scaled");
 
     gl_->DeleteTextures(1, &src_texture);
     gl_->DeleteTextures(1, &dst_texture);
     gl_->DeleteFramebuffers(1, &framebuffer);
   }
 
   // Create a scaling pipeline and check that it is made up of
   // valid scaling operations.
   void TestScalerPipeline(size_t quality,
                           int xsize,
                           int ysize,
                           int dst_xsize,
                           int dst_ysize) {
     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,
+    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]));
+                         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,
-                         gfx::Size(dst_xsize, dst_ysize),
-                         "");
+    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), "");
     EXPECT_EQ(PrintStages(stages), description);
   }
 
   // Note: Left/Right means Top/Bottom when used for Y dimension.
   enum Margin {
     MarginLeft,
     MarginMiddle,
     MarginRight,
     MarginInvalid,
   };
@@ skipping 82 matching lines @@
             PrintChannel(source, 1);
             LOG(ERROR) << "-------before yuv conversion: blue-------";
             PrintChannel(source, 2);
           }
           return;
         }
       }
     }
   }
 
-  void DrawGridToBitmap(int w, int h,
+  void DrawGridToBitmap(int w,
+                        int h,
                         SkColor background_color,
                         SkColor grid_color,
                         int grid_pitch,
                         int grid_width,
                         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,
+  void DrawCheckerToBitmap(int w,
+                           int h,
+                           SkColor color1,
+                           SkColor color2,
+                           int rect_w,
+                           int rect_h,
                            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 23 matching lines @@
       case kRGB_565_SkColorType:
         result = (std::abs(c1 - c2) <= 7);
         break;
       default:
         break;
     }
     return result;
   }
 
   bool ColorsClose(SkColor color1, SkColor color2, SkColorType color_type) {
-    bool red = ColorComponentsClose(SkColorGetR(color1),
-                                    SkColorGetR(color2), color_type);
-    bool green = ColorComponentsClose(SkColorGetG(color1),
-                                        SkColorGetG(color2), color_type);
-    bool blue = ColorComponentsClose(SkColorGetB(color1),
-                                     SkColorGetB(color2), color_type);
-    bool alpha = ColorComponentsClose(SkColorGetA(color1),
-                                      SkColorGetA(color2), color_type);
+    bool red = ColorComponentsClose(SkColorGetR(color1), SkColorGetR(color2),
+                                    color_type);
+    bool green = ColorComponentsClose(SkColorGetG(color1), SkColorGetG(color2),
+                                      color_type);
+    bool blue = ColorComponentsClose(SkColorGetB(color1), SkColorGetB(color2),
+                                     color_type);
+    bool alpha = ColorComponentsClose(SkColorGetA(color1), SkColorGetA(color2),
+                                      color_type);
     if (color_type == kRGB_565_SkColorType) {
       return red && blue && green;
     }
     return red && blue && green && alpha;
   }
 
   bool IsEqual(const SkBitmap& bmp1, const SkBitmap& bmp2) {
     if (bmp1.isNull() && bmp2.isNull())
       return true;
-    if (bmp1.width() != bmp2.width() ||
-        bmp1.height() != bmp2.height()) {
-        LOG(ERROR) << "Bitmap geometry check failure";
-        return false;
+    if (bmp1.width() != bmp2.width() || bmp1.height() != bmp2.height()) {
+      LOG(ERROR) << "Bitmap geometry check failure";
+      return false;
     }
     if (bmp1.colorType() != bmp2.colorType())
       return false;
 
     SkAutoLockPixels lock1(bmp1);
     SkAutoLockPixels lock2(bmp2);
     if (!bmp1.getPixels() || !bmp2.getPixels()) {
       LOG(ERROR) << "Empty Bitmap!";
       return false;
     }
     for (int y = 0; y < bmp1.height(); ++y) {
       for (int x = 0; x < bmp1.width(); ++x) {
-        if (!ColorsClose(bmp1.getColor(x,y),
-                         bmp2.getColor(x,y),
+        if (!ColorsClose(bmp1.getColor(x, y), bmp2.getColor(x, y),
                          bmp1.colorType())) {
           LOG(ERROR) << "Bitmap color comparision failure";
           return false;
         }
       }
     }
     return true;
   }
 
   void BindAndAttachTextureWithPixels(GLuint src_texture,
@@ skipping 22 matching lines @@
                     input_pixels.getPixels());
   }
 
   void ReadBackTexture(GLuint src_texture,
                        const gfx::Size& src_size,
                        unsigned char* pixels,
                        SkColorType color_type,
                        bool async) {
     if (async) {
       base::RunLoop run_loop;
-      helper_->ReadbackTextureAsync(src_texture,
-                                    src_size,
-                                    pixels,
-                                    color_type,
-                                    base::Bind(&callcallback,
-                                               run_loop.QuitClosure()));
+      helper_->ReadbackTextureAsync(
+          src_texture, src_size, pixels, color_type,
+          base::Bind(&callcallback, run_loop.QuitClosure()));
       run_loop.Run();
     } else {
-      helper_->ReadbackTextureSync(src_texture,
-                                   gfx::Rect(src_size),
-                                   pixels,
+      helper_->ReadbackTextureSync(src_texture, gfx::Rect(src_size), pixels,
                                    color_type);
     }
   }
   // Test basic format readback.
   bool TestTextureFormatReadback(const gfx::Size& src_size,
-                         SkColorType color_type,
-                         bool async) {
-    SkImageInfo info =
-        SkImageInfo::Make(src_size.width(),
-                          src_size.height(),
-                          color_type,
-                          kPremul_SkAlphaType);
+                                 SkColorType color_type,
+                                 bool async) {
+    SkImageInfo info = SkImageInfo::Make(src_size.width(), src_size.height(),
+                                         color_type, kPremul_SkAlphaType);
     if (!helper_->IsReadbackConfigSupported(color_type)) {
       LOG(INFO) << "Skipping test format not supported" << color_type;
       return true;
     }
     GLuint src_texture;
     gl_->GenTextures(1, &src_texture);
     SkBitmap input_pixels;
     input_pixels.allocPixels(info);
     // Test Pattern-1, Fill with Plain color pattern.
     // Erase the input bitmap with red color.
     input_pixels.eraseColor(SK_ColorRED);
-    BindAndAttachTextureWithPixels(src_texture,
-                                   color_type,
-                                   src_size,
+    BindAndAttachTextureWithPixels(src_texture, color_type, src_size,
                                    input_pixels);
     SkBitmap output_pixels;
     output_pixels.allocPixels(info);
     // Initialize the output bitmap with Green color.
     // When the readback is over output bitmap should have the red color.
     output_pixels.eraseColor(SK_ColorGREEN);
     uint8_t* pixels = static_cast<uint8_t*>(output_pixels.getPixels());
     ReadBackTexture(src_texture, src_size, pixels, color_type, async);
     bool result = IsEqual(input_pixels, output_pixels);
     if (!result) {
       LOG(ERROR) << "Bitmap comparision failure Pattern-1";
       return false;
     }
     const int rect_w = 10, rect_h = 4, src_grid_pitch = 10, src_grid_width = 4;
     const SkColor color1 = SK_ColorRED, color2 = SK_ColorBLUE;
     // Test Pattern-2, Fill with Grid Pattern.
-    DrawGridToBitmap(src_size.width(), src_size.height(),
-                   color2, color1,
-                   src_grid_pitch, src_grid_width,
-                   input_pixels);
-    BindAndAttachTextureWithPixels(src_texture,
-                                   color_type,
-                                   src_size,
+    DrawGridToBitmap(src_size.width(), src_size.height(), color2, color1,
+                     src_grid_pitch, src_grid_width, input_pixels);
+    BindAndAttachTextureWithPixels(src_texture, color_type, src_size,
                                    input_pixels);
     ReadBackTexture(src_texture, src_size, pixels, color_type, async);
     result = IsEqual(input_pixels, output_pixels);
     if (!result) {
       LOG(ERROR) << "Bitmap comparision failure Pattern-2";
       return false;
     }
     // Test Pattern-3, Fill with CheckerBoard Pattern.
-    DrawCheckerToBitmap(src_size.width(),
-                    src_size.height(),
-                    color1,
-                    color2, rect_w, rect_h, input_pixels);
-    BindAndAttachTextureWithPixels(src_texture,
-                                   color_type,
-                                   src_size,
+    DrawCheckerToBitmap(src_size.width(), src_size.height(), color1, color2,
+                        rect_w, rect_h, input_pixels);
+    BindAndAttachTextureWithPixels(src_texture, color_type, src_size,
                                    input_pixels);
     ReadBackTexture(src_texture, src_size, pixels, color_type, async);
     result = IsEqual(input_pixels, output_pixels);
     if (!result) {
       LOG(ERROR) << "Bitmap comparision failure Pattern-3";
       return false;
     }
     gl_->DeleteTextures(1, &src_texture);
     if (HasFailure()) {
       return false;
@@ skipping 56 matching lines @@
     gl_->ShallowFlushCHROMIUM();
 
     gpu::SyncToken sync_token;
     gl_->GenSyncTokenCHROMIUM(fence_sync, sync_token.GetData());
 
     std::string message = base::StringPrintf(
         "input size: %dx%d "
         "output size: %dx%d "
         "margin: %dx%d "
         "pattern: %d %s %s",
-        xsize,
-        ysize,
-        output_xsize,
-        output_ysize,
-        xmargin,
-        ymargin,
-        test_pattern,
-        flip ? "flip" : "noflip",
-        flip ? "mrt" : "nomrt");
+        xsize, ysize, output_xsize, output_ysize, xmargin, ymargin,
+        test_pattern, flip ? "flip" : "noflip", flip ? "mrt" : "nomrt");
     scoped_ptr<ReadbackYUVInterface> yuv_reader(
         helper_->CreateReadbackPipelineYUV(
-            quality,
-            gfx::Size(xsize, ysize),
-            gfx::Rect(0, 0, xsize, ysize),
-            gfx::Size(xsize, ysize),
-            flip,
-            use_mrt));
+            quality, gfx::Size(xsize, ysize), gfx::Rect(0, 0, xsize, ysize),
+            gfx::Size(xsize, ysize), flip, use_mrt));
 
     scoped_refptr<media::VideoFrame> output_frame =
         media::VideoFrame::CreateFrame(
             media::PIXEL_FORMAT_YV12,
             // The coded size of the output frame is rounded up to the next
             // 16-byte boundary.  This tests that the readback is being
             // positioned inside the frame's visible region, and not dependent
             // on its coded size.
             gfx::Size((output_xsize + 15) & ~15, (output_ysize + 15) & ~15),
             gfx::Rect(0, 0, output_xsize, output_ysize),
@@ skipping 54 matching lines @@
             float_to_byte(Bilinear(&input_pixels, x * 2 + 1.0, y * 2 + 1.0, 0) *
                               kRGBtoVColorWeights[0] +
                           Bilinear(&input_pixels, x * 2 + 1.0, y * 2 + 1.0, 1) *
                               kRGBtoVColorWeights[1] +
                           Bilinear(&input_pixels, x * 2 + 1.0, y * 2 + 1.0, 2) *
                               kRGBtoVColorWeights[2] +
                           kRGBtoVColorWeights[3]);
       }
     }
 
-    ComparePlane(Y,
-                 y_stride,
-                 output_frame->visible_data(media::VideoFrame::kYPlane),
-                 output_frame->stride(media::VideoFrame::kYPlane),
-                 2,
-                 output_xsize,
-                 output_ysize,
-                 &input_pixels,
-                 message + " Y plane");
-    ComparePlane(U,
-                 u_stride,
-                 output_frame->visible_data(media::VideoFrame::kUPlane),
-                 output_frame->stride(media::VideoFrame::kUPlane),
-                 2,
-                 output_xsize / 2,
-                 output_ysize / 2,
-                 &input_pixels,
-                 message + " U plane");
-    ComparePlane(V,
-                 v_stride,
-                 output_frame->visible_data(media::VideoFrame::kVPlane),
-                 output_frame->stride(media::VideoFrame::kVPlane),
-                 2,
-                 output_xsize / 2,
-                 output_ysize / 2,
-                 &input_pixels,
-                 message + " V plane");
+    ComparePlane(
+        Y, y_stride, output_frame->visible_data(media::VideoFrame::kYPlane),
+        output_frame->stride(media::VideoFrame::kYPlane), 2, output_xsize,
+        output_ysize, &input_pixels, message + " Y plane");
+    ComparePlane(
+        U, u_stride, output_frame->visible_data(media::VideoFrame::kUPlane),
+        output_frame->stride(media::VideoFrame::kUPlane), 2, output_xsize / 2,
+        output_ysize / 2, &input_pixels, message + " U plane");
+    ComparePlane(
+        V, v_stride, output_frame->visible_data(media::VideoFrame::kVPlane),
+        output_frame->stride(media::VideoFrame::kVPlane), 2, output_xsize / 2,
+        output_ysize / 2, &input_pixels, message + " V plane");
 
     gl_->DeleteTextures(1, &src_texture);
   }
 
   void TestAddOps(int src, int dst, bool scale_x, bool allow3) {
     std::deque<GLHelperScaling::ScaleOp> ops;
     GLHelperScaling::ScaleOp::AddOps(src, dst, scale_x, allow3, &ops);
     // Scale factor 3 is a special case.
     // It is currently only allowed by itself.
     if (allow3 && dst * 3 >= src && dst * 2 < src) {
@@ skipping 30 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);
+        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);
     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(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.
@@ skipping 26 matching lines @@
     // 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));
     y_ops_.push_back(GLHelperScaling::ScaleOp(3, false, 40));
-    CheckPipeline2(100,
-                   100,
-                   40,
-                   40,
+    CheckPipeline2(100, 100, 40, 40,
                    "100x100 -> 100x40 bilinear3 Y\n"
                    "100x40 -> 40x40 bilinear3 X\n");
 
     // X scaled to 60%, Y scaled 40%
     x_ops_.push_back(GLHelperScaling::ScaleOp(0, true, 120));
     x_ops_.push_back(GLHelperScaling::ScaleOp(2, true, 60));
     y_ops_.push_back(GLHelperScaling::ScaleOp(3, false, 40));
-    CheckPipeline2(100,
-                   100,
-                   60,
-                   40,
+    CheckPipeline2(100, 100, 60, 40,
                    "100x100 -> 100x40 bilinear3 Y\n"
                    "100x40 -> 60x40 bilinear2 X\n");
 
     // X scaled to 40%, Y scaled 60%
     x_ops_.push_back(GLHelperScaling::ScaleOp(3, true, 40));
     y_ops_.push_back(GLHelperScaling::ScaleOp(0, false, 120));
     y_ops_.push_back(GLHelperScaling::ScaleOp(2, false, 60));
-    CheckPipeline2(100,
-                   100,
-                   40,
-                   60,
+    CheckPipeline2(100, 100, 40, 60,
                    "100x100 -> 100x60 bilinear2 Y\n"
                    "100x60 -> 40x60 bilinear3 X\n");
 
     // X scaled to 30%, Y scaled 30%
     x_ops_.push_back(GLHelperScaling::ScaleOp(0, true, 120));
     x_ops_.push_back(GLHelperScaling::ScaleOp(2, true, 60));
     x_ops_.push_back(GLHelperScaling::ScaleOp(2, true, 30));
     y_ops_.push_back(GLHelperScaling::ScaleOp(0, false, 120));
     y_ops_.push_back(GLHelperScaling::ScaleOp(2, false, 60));
     y_ops_.push_back(GLHelperScaling::ScaleOp(2, false, 30));
-    CheckPipeline2(100,
-                   100,
-                   30,
-                   30,
+    CheckPipeline2(100, 100, 30, 30,
                    "100x100 -> 100x30 bilinear4 Y\n"
                    "100x30 -> 30x30 bilinear4 X\n");
 
     // X scaled to 50%, Y scaled 30%
     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));
     y_ops_.push_back(GLHelperScaling::ScaleOp(2, false, 30));
     CheckPipeline2(100, 100, 50, 30, "100x100 -> 50x30 bilinear4 Y\n");
 
     // X scaled to 150%, Y scaled 30%
     // Note that we avoid combinding X and Y passes
     // as that would probably be LESS efficient here.
     x_ops_.push_back(GLHelperScaling::ScaleOp(0, true, 150));
     y_ops_.push_back(GLHelperScaling::ScaleOp(0, false, 120));
     y_ops_.push_back(GLHelperScaling::ScaleOp(2, false, 60));
     y_ops_.push_back(GLHelperScaling::ScaleOp(2, false, 30));
-    CheckPipeline2(100,
-                   100,
-                   150,
-                   30,
+    CheckPipeline2(100, 100, 150, 30,
                    "100x100 -> 100x30 bilinear4 Y\n"
                    "100x30 -> 150x30 bilinear\n");
 
     // X scaled to 1%, Y scaled 1%
     x_ops_.push_back(GLHelperScaling::ScaleOp(0, true, 128));
     x_ops_.push_back(GLHelperScaling::ScaleOp(2, true, 64));
     x_ops_.push_back(GLHelperScaling::ScaleOp(2, true, 32));
     x_ops_.push_back(GLHelperScaling::ScaleOp(2, true, 16));
     x_ops_.push_back(GLHelperScaling::ScaleOp(2, true, 8));
     x_ops_.push_back(GLHelperScaling::ScaleOp(2, true, 4));
     x_ops_.push_back(GLHelperScaling::ScaleOp(2, true, 2));
     x_ops_.push_back(GLHelperScaling::ScaleOp(2, true, 1));
     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,
-                   1,
-                   1,
+    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");
   }
 
   scoped_ptr<gpu::GLInProcessContext> context_;
   gpu::gles2::GLES2Interface* gl_;
   scoped_ptr<content::GLHelper> helper_;
   scoped_ptr<content::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;
-  bool result = TestTextureFormatReadback(gfx::Size(kTestSize,kTestSize),
-                                          kRGBA_8888_SkColorType,
-                                          false);
+  bool result = TestTextureFormatReadback(gfx::Size(kTestSize, kTestSize),
+                                          kRGBA_8888_SkColorType, false);
   EXPECT_EQ(result, true);
 }
 
-
 TEST_F(GLHelperTest, BGRASyncReadbackTest) {
   const int kTestSize = 64;
-  bool result = TestTextureFormatReadback(gfx::Size(kTestSize,kTestSize),
-                                          kBGRA_8888_SkColorType,
-                                          false);
+  bool result = TestTextureFormatReadback(gfx::Size(kTestSize, kTestSize),
+                                          kBGRA_8888_SkColorType, false);
   EXPECT_EQ(result, true);
 }
 
 TEST_F(GLHelperTest, RGB565SyncReadbackTest) {
   const int kTestSize = 64;
-  bool result = TestTextureFormatReadback(gfx::Size(kTestSize,kTestSize),
-                                          kRGB_565_SkColorType,
-                                          false);
+  bool result = TestTextureFormatReadback(gfx::Size(kTestSize, kTestSize),
+                                          kRGB_565_SkColorType, false);
   EXPECT_EQ(result, true);
 }
 
 TEST_F(GLHelperTest, RGBAASyncReadbackTest) {
   const int kTestSize = 64;
-  bool result = TestTextureFormatReadback(gfx::Size(kTestSize,kTestSize),
-                                          kRGBA_8888_SkColorType,
-                                          true);
+  bool result = TestTextureFormatReadback(gfx::Size(kTestSize, kTestSize),
+                                          kRGBA_8888_SkColorType, true);
   EXPECT_EQ(result, true);
 }
 
 TEST_F(GLHelperTest, BGRAASyncReadbackTest) {
   const int kTestSize = 64;
-  bool result = TestTextureFormatReadback(gfx::Size(kTestSize,kTestSize),
-                                          kBGRA_8888_SkColorType,
-                                          true);
+  bool result = TestTextureFormatReadback(gfx::Size(kTestSize, kTestSize),
+                                          kBGRA_8888_SkColorType, true);
   EXPECT_EQ(result, true);
 }
 
 TEST_F(GLHelperTest, RGB565ASyncReadbackTest) {
   const int kTestSize = 64;
-  bool result = TestTextureFormatReadback(gfx::Size(kTestSize,kTestSize),
-                                          kRGB_565_SkColorType,
-                                          true);
+  bool result = TestTextureFormatReadback(gfx::Size(kTestSize, kTestSize),
+                                          kRGB_565_SkColorType, true);
   EXPECT_EQ(result, true);
 }
 
 TEST_F(GLHelperPixelTest, YUVReadbackOptTest) {
   // This test uses the gpu.service/gpu_decoder tracing events to detect how
   // many scaling passes are actually performed by the YUV readback pipeline.
-  StartTracing(TRACE_DISABLED_BY_DEFAULT("gpu.service") ","
-               TRACE_DISABLED_BY_DEFAULT("gpu_decoder"));
+  StartTracing(TRACE_DISABLED_BY_DEFAULT(
+      "gpu.service") "," TRACE_DISABLED_BY_DEFAULT("gpu_decoder"));
 
-  TestYUVReadback(800,
-                  400,
-                  800,
-                  400,
-                  0,
-                  0,
-                  1,
-                  false,
-                  true,
+  TestYUVReadback(800, 400, 800, 400, 0, 0, 1, false, true,
                   content::GLHelper::SCALER_QUALITY_FAST);
 
   std::map<std::string, int> event_counts;
   EndTracing(&event_counts);
   int draw_buffer_calls = event_counts["kDrawBuffersEXTImmediate"];
   int draw_arrays_calls = event_counts["kDrawArrays"];
   VLOG(1) << "Draw buffer calls: " << draw_buffer_calls;
   VLOG(1) << "DrawArrays calls: " << draw_arrays_calls;
 
   if (draw_buffer_calls) {
     // When using MRT, the YUV readback code should only
     // execute two draw arrays, and scaling should be integrated
     // into those two calls since we are using the FAST scalign
     // quality.
     EXPECT_EQ(2, draw_arrays_calls);
   } else {
     // When not using MRT, there are three passes for the YUV,
     // and one for the scaling.
     EXPECT_EQ(4, draw_arrays_calls);
   }
 }
 
-class GLHelperPixelYuvReadback :
-    public GLHelperPixelTest,
-    public ::testing::WithParamInterface<
-        std::tr1::tuple<bool, bool, unsigned int, unsigned int>> {};
+class GLHelperPixelYuvReadback
+    : public GLHelperPixelTest,
+      public ::testing::WithParamInterface<
+          std::tr1::tuple<bool, bool, unsigned int, unsigned int>> {};
 
 int kYUVReadBackSizes[] = {2, 4, 14};
 
 TEST_P(GLHelperPixelYuvReadback, Test) {
   bool flip = std::tr1::get<0>(GetParam());
   bool use_mrt = std::tr1::get<1>(GetParam());
   unsigned int x = std::tr1::get<2>(GetParam());
   unsigned int y = std::tr1::get<3>(GetParam());
 
   for (unsigned int ox = x; ox < arraysize(kYUVReadBackSizes); ox++) {
     for (unsigned int oy = y; oy < arraysize(kYUVReadBackSizes); oy++) {
       // If output is a subsection of the destination frame, (letterbox)
       // then try different variations of where the subsection goes.
-      for (Margin xm = x < ox ? MarginLeft : MarginRight;
-           xm <= MarginRight;
+      for (Margin xm = x < ox ? MarginLeft : MarginRight; xm <= MarginRight;
            xm = NextMargin(xm)) {
-        for (Margin ym = y < oy ? MarginLeft : MarginRight;
-             ym <= MarginRight;
+        for (Margin ym = y < oy ? MarginLeft : MarginRight; ym <= MarginRight;
              ym = NextMargin(ym)) {
           for (int pattern = 0; pattern < 3; pattern++) {
-            TestYUVReadback(kYUVReadBackSizes[x],
-                            kYUVReadBackSizes[y],
-                            kYUVReadBackSizes[ox],
-                            kYUVReadBackSizes[oy],
-                            compute_margin(kYUVReadBackSizes[x],
-                                           kYUVReadBackSizes[ox], xm),
-                            compute_margin(kYUVReadBackSizes[y],
-                                           kYUVReadBackSizes[oy], ym),
-                            pattern,
-                            flip,
-                            use_mrt,
-                            content::GLHelper::SCALER_QUALITY_GOOD);
+            TestYUVReadback(
+                kYUVReadBackSizes[x], kYUVReadBackSizes[y],
+                kYUVReadBackSizes[ox], kYUVReadBackSizes[oy],
+                compute_margin(kYUVReadBackSizes[x], kYUVReadBackSizes[ox], xm),
+                compute_margin(kYUVReadBackSizes[y], kYUVReadBackSizes[oy], ym),
+                pattern, flip, use_mrt, content::GLHelper::SCALER_QUALITY_GOOD);
             if (HasFailure()) {
               return;
             }
           }
         }
       }
     }
   }
 }
 
 // First argument is intentionally empty.
 INSTANTIATE_TEST_CASE_P(
     ,
     GLHelperPixelYuvReadback,
     ::testing::Combine(
-         ::testing::Bool(),
-         ::testing::Bool(),
-         ::testing::Range<unsigned int>(0, arraysize(kYUVReadBackSizes)),
-         ::testing::Range<unsigned int>(0, arraysize(kYUVReadBackSizes))));
-
+        ::testing::Bool(),
+        ::testing::Bool(),
+        ::testing::Range<unsigned int>(0, arraysize(kYUVReadBackSizes)),
+        ::testing::Range<unsigned int>(0, arraysize(kYUVReadBackSizes))));
 
 int kRGBReadBackSizes[] = {3, 6, 16};
 
-class GLHelperPixelReadbackTest :
-    public GLHelperPixelTest,
-    public ::testing::WithParamInterface<
-        std::tr1::tuple<unsigned int,
-                        unsigned int,
-                        unsigned int,
-                        unsigned int,
-                        unsigned int>> {};
+class GLHelperPixelReadbackTest
+    : public GLHelperPixelTest,
+      public ::testing::WithParamInterface<std::tr1::tuple<unsigned int,
+                                                           unsigned int,
+                                                           unsigned int,
+                                                           unsigned int,
+                                                           unsigned int>> {};
 
 // Per pixel tests, all sizes are small so that we can print
 // out the generated bitmaps.
 TEST_P(GLHelperPixelReadbackTest, ScaleTest) {
   unsigned int q_index = std::tr1::get<0>(GetParam());
   unsigned int x = std::tr1::get<1>(GetParam());
   unsigned int y = std::tr1::get<2>(GetParam());
   unsigned int dst_x = std::tr1::get<3>(GetParam());
   unsigned int dst_y = std::tr1::get<4>(GetParam());
 
   for (int flip = 0; flip <= 1; flip++) {
     for (int pattern = 0; pattern < 3; pattern++) {
-      TestScale(kRGBReadBackSizes[x],
-                kRGBReadBackSizes[y],
-                kRGBReadBackSizes[dst_x],
-                kRGBReadBackSizes[dst_y],
-                pattern,
-                q_index,
-                flip == 1);
+      TestScale(kRGBReadBackSizes[x], kRGBReadBackSizes[y],
+                kRGBReadBackSizes[dst_x], kRGBReadBackSizes[dst_y], pattern,
+                q_index, flip == 1);
       if (HasFailure()) {
         return;
       }
     }
   }
 }
 
-
 // Per pixel tests, all sizes are small so that we can print
 // out the generated bitmaps.
 TEST_P(GLHelperPixelReadbackTest, CropScaleReadbackAndCleanTextureTest) {
   unsigned int q_index = std::tr1::get<0>(GetParam());
   unsigned int x = std::tr1::get<1>(GetParam());
   unsigned int y = std::tr1::get<2>(GetParam());
   unsigned int dst_x = std::tr1::get<3>(GetParam());
   unsigned int dst_y = std::tr1::get<4>(GetParam());
 
   const SkColorType kColorTypes[] = {
       kAlpha_8_SkColorType, kRGBA_8888_SkColorType, kBGRA_8888_SkColorType};
   for (size_t color_type = 0; color_type < arraysize(kColorTypes);
        color_type++) {
     for (int pattern = 0; pattern < 3; pattern++) {
-      TestCropScaleReadbackAndCleanTexture(kRGBReadBackSizes[x],
-                                           kRGBReadBackSizes[y],
-                                           kRGBReadBackSizes[dst_x],
-                                           kRGBReadBackSizes[dst_y],
-                                           pattern,
-                                           kColorTypes[color_type],
-                                           false,
-                                           q_index);
+      TestCropScaleReadbackAndCleanTexture(
+          kRGBReadBackSizes[x], kRGBReadBackSizes[y], kRGBReadBackSizes[dst_x],
+          kRGBReadBackSizes[dst_y], pattern, kColorTypes[color_type], false,
+          q_index);
       if (HasFailure())
         return;
     }
   }
 }
 
 INSTANTIATE_TEST_CASE_P(
     ,
     GLHelperPixelReadbackTest,
     ::testing::Combine(
-         ::testing::Range<unsigned int>(0, arraysize(kQualities)),
-         ::testing::Range<unsigned int>(0, arraysize(kRGBReadBackSizes)),
-         ::testing::Range<unsigned int>(0, arraysize(kRGBReadBackSizes)),
-         ::testing::Range<unsigned int>(0, arraysize(kRGBReadBackSizes)),
-         ::testing::Range<unsigned int>(0, arraysize(kRGBReadBackSizes))));
+        ::testing::Range<unsigned int>(0, arraysize(kQualities)),
+        ::testing::Range<unsigned int>(0, arraysize(kRGBReadBackSizes)),
+        ::testing::Range<unsigned int>(0, arraysize(kRGBReadBackSizes)),
+        ::testing::Range<unsigned int>(0, arraysize(kRGBReadBackSizes)),
+        ::testing::Range<unsigned int>(0, arraysize(kRGBReadBackSizes))));
 
 // Validate that all scaling generates valid pipelines.
 TEST_F(GLHelperTest, ValidateScalerPipelines) {
   int sizes[] = {7, 99, 128, 256, 512, 719, 720, 721, 1920, 2011, 3217, 4096};
   for (size_t q = 0; q < arraysize(kQualities); q++) {
     for (size_t x = 0; x < arraysize(sizes); x++) {
       for (size_t y = 0; y < arraysize(sizes); y++) {
         for (size_t dst_x = 0; dst_x < arraysize(sizes); dst_x++) {
           for (size_t dst_y = 0; dst_y < arraysize(sizes); dst_y++) {
-            TestScalerPipeline(
-                q, sizes[x], sizes[y], sizes[dst_x], sizes[dst_y]);
+            TestScalerPipeline(q, sizes[x], sizes[y], sizes[dst_x],
+                               sizes[dst_y]);
             if (HasFailure()) {
               return;
             }
           }
         }
       }
     }
   }
 }
 
 // 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,
+  CheckPipeline(content::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,
+  CheckPipeline(content::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(content::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