Add Async API unittests to readback format.

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 890 matching lines @@
           LOG(ERROR) << "Bitmap color comparision failure";
           return false;
         }
       }
     }
     return true;
   }
 
   // Test basic format readback.
   bool TestTextureFormatReadback(const gfx::Size& src_size,
-                         SkBitmap::Config bitmap_config) {
+                         SkBitmap::Config bitmap_config,
+                         bool readback_async) {
     DCHECK((bitmap_config == SkBitmap::kRGB_565_Config) ||
            (bitmap_config == SkBitmap::kARGB_8888_Config));
     bool rgb565_format = (bitmap_config == SkBitmap::kRGB_565_Config);
     if (rgb565_format && !helper_->CanUseRgb565Readback()) {
       LOG(INFO) << "RGB565 Format Not supported on this platform";
       LOG(INFO) << "Skipping RGB565ReadBackTest";
       return true;
     }
     WebGLId src_texture = context_->createTexture();
     SkBitmap input_pixels;
@@ skipping 19 matching lines @@
                          input_pixels.getPixels());
     SkBitmap output_pixels;
     output_pixels.setConfig(bitmap_config, src_size.width(),
                            src_size.height());
     output_pixels.allocPixels();
     SkAutoLockPixels lock2(output_pixels);
     // 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* pixels = static_cast<uint8*>(output_pixels.getPixels());
-    helper_->ReadbackTextureSync(src_texture,
-                                 gfx::Rect(src_size),
-                                 pixels,
-                                 bitmap_config);
+    if (readback_async) {
+      base::RunLoop run_loop;
+      helper_->ReadbackTextureAsync(src_texture,
+                                    src_size,
+                                    pixels,
+                                    bitmap_config,
+                                    base::Bind(&callcallback,
+                                               run_loop.QuitClosure()));
+      run_loop.Run();
+    } else {
+      helper_->ReadbackTextureSync(src_texture,
+                                   gfx::Rect(src_size),
+                                   pixels,
+                                   bitmap_config);
+    }
     bool result = IsEqual(input_pixels, output_pixels);
     if (!result) {
       LOG(ERROR) << "Bitmap comparision failure";
       return false;
     }
     context_->deleteTexture(src_texture);
     if (HasFailure()) {
       return false;
     }
     return true;
@@ skipping 367 matching lines @@
                    "8x1 -> 1x1 bilinear4 X\n");
   }
 
   scoped_ptr<WebGraphicsContext3DInProcessCommandBufferImpl> context_;
   gpu::ContextSupport* context_support_;
   scoped_ptr<content::GLHelper> helper_;
   scoped_ptr<content::GLHelperScaling> helper_scaling_;
   std::deque<GLHelperScaling::ScaleOp> x_ops_, y_ops_;
 };
 
-TEST_F(GLHelperTest, RGBAReadBackTest) {
+TEST_F(GLHelperTest, ARGBSyncReadbackTest) {
   const int kTestSize = 64;
   bool result = TestTextureFormatReadback(gfx::Size(kTestSize,kTestSize),
-                                          SkBitmap::kARGB_8888_Config);
+                                          SkBitmap::kARGB_8888_Config,
+                                          false);
   EXPECT_EQ(result, true);
 }
 
-TEST_F(GLHelperTest, RGB565ReadBackTest) {
+TEST_F(GLHelperTest, RGB565SyncReadbackTest) {
   const int kTestSize = 64;
   bool result = TestTextureFormatReadback(gfx::Size(kTestSize,kTestSize),
-                                          SkBitmap::kRGB_565_Config);
+                                          SkBitmap::kRGB_565_Config,
+                                          false);
   EXPECT_EQ(result, true);
 }
 
+TEST_F(GLHelperTest, ARGBASyncReadbackTest) {
+  const int kTestSize = 64;
+  bool result = TestTextureFormatReadback(gfx::Size(kTestSize,kTestSize),
+                                          SkBitmap::kARGB_8888_Config,
+                                          true);
+  EXPECT_EQ(result, true);
+}
+
+TEST_F(GLHelperTest, RGB565ASyncReadbackTest) {
+  const int kTestSize = 64;
+  bool result = TestTextureFormatReadback(gfx::Size(kTestSize,kTestSize),
+                                          SkBitmap::kRGB_565_Config,
+                                          true);
+  EXPECT_EQ(result, true);
+}
+
 TEST_F(GLHelperTest, YUVReadbackOptTest) {
   // This test uses the cb_command tracing events to detect how many
   // scaling passes are actually performed by the YUV readback pipeline.
   StartTracing(TRACE_DISABLED_BY_DEFAULT("cb_command"));
 
   TestYUVReadback(800,
                   400,
                   800,
                   400,
                   0,
@@ skipping 175 matching lines @@
 #if defined(TOOLKIT_GTK)
   gfx::GtkInitFromCommandLine(*CommandLine::ForCurrentProcess());
 #endif
   gfx::GLSurface::InitializeOneOff();
   gpu::ApplyGpuDriverBugWorkarounds(CommandLine::ForCurrentProcess());
 
   content::UnitTestTestSuite runner(suite);
   base::MessageLoop message_loop;
   return runner.Run();
 }