enable SSE2 in skia/convolver for linux32

skia/ext/convolver_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <string.h>
 #include <time.h>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
@@ skipping 193 matching lines @@
   ASSERT_EQ(6, filter.max_filter());
   ASSERT_EQ(6, filter.num_values());
 
   values = filter.FilterForValue(5, &filter_offset, &filter_length);
   ASSERT_TRUE(values == NULL);   // filter_length == 0 => values is NULL
   ASSERT_EQ(66, filter_offset);  // value passed in
   ASSERT_EQ(0, filter_length);
 }
 
 TEST(Convolver, SIMDVerification) {
-#if defined(SIMD_SSE2)
-  base::CPU cpu;
-  if (!cpu.has_sse2()) return;
-
   int source_sizes[][2] = {
     {1,1}, {1,2}, {1,3}, {1,4}, {1,5},
     {2,1}, {2,2}, {2,3}, {2,4}, {2,5},
     {3,1}, {3,2}, {3,3}, {3,4}, {3,5},
     {4,1}, {4,2}, {4,3}, {4,4}, {4,5},
     {1920, 1080},
     {720, 480},
     {1377, 523},
     {325, 241} };
   int dest_sizes[][2] = { {1280, 1024}, {480, 270}, {177, 123} };
@@ skipping 11 matching lines @@
 
       // Preparing convolve coefficients.
       ConvolutionFilter1D x_filter, y_filter;
       for (unsigned int p = 0; p < dest_width; ++p) {
         unsigned int offset = source_width * p / dest_width;
         EXPECT_LT(offset, source_width);
         x_filter.AddFilter(offset, filter,
                            std::min<int>(arraysize(filter),
                                          source_width - offset));
       }
-      x_filter.PaddingForSIMD(8);
+      x_filter.PaddingForSIMD();
       for (unsigned int p = 0; p < dest_height; ++p) {
         unsigned int offset = source_height * p / dest_height;
         y_filter.AddFilter(offset, filter,
                            std::min<int>(arraysize(filter),
                                          source_height - offset));
       }
-      y_filter.PaddingForSIMD(8);
+      y_filter.PaddingForSIMD();
 
       // Allocate input and output skia bitmap.
       SkBitmap source, result_c, result_sse;
       source.setConfig(SkBitmap::kARGB_8888_Config,
                        source_width, source_height);
       source.allocPixels();
       result_c.setConfig(SkBitmap::kARGB_8888_Config,
                          dest_width, dest_height);
       result_c.allocPixels();
       result_sse.setConfig(SkBitmap::kARGB_8888_Config,
@@ skipping 52 matching lines @@
         for (unsigned int i = 0; i < dest_height; i++) {
           for (unsigned int x = 0; x < dest_width * 4; x++) {  // RGBA always.
             EXPECT_EQ(r1[x], r2[x]);
           }
           r1 += result_c.rowBytes();
           r2 += result_sse.rowBytes();
         }
       }
     }
   }
-#endif
 }
 
 }  // namespace skia