Add key pixel check option in GpuPixelBrowserTest.

chrome/test/gpu/gpu_pixel_browsertest.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 "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
+#include "base/stringprintf.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/window_snapshot/window_snapshot.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/test_launcher_utils.h"
 #include "chrome/test/base/tracing.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/test/gpu/test_switches.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/net_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/compositor/compositor_setup.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/size.h"
 #include "ui/gl/gl_switches.h"
 
 namespace {
 
+enum ReferenceImageOption {
+  kReferenceImageLocal,
+  kReferenceImageCheckedIn,
+  kReferenceImageNone  // Only check a few key pixels.
+};
+
+struct ReferencePixel {
+  int x, y;
+  unsigned char r, g, b;
+};
+
 // Command line flag for overriding the default location for putting generated
 // test images that do not match references.
 const char kGeneratedDir[] = "generated-dir";
 // Command line flag for overriding the default location for reference images.
 const char kReferenceDir[] = "reference-dir";
 
 // Corner shadow size.
 const int kCornerDecorationSize = 15;
 // Side shadow size.
 const int kSideDecorationSize = 2;
@@ skipping 37 matching lines @@
 
 }  // namespace
 
 // Test fixture for GPU image comparison tests.
 // TODO(kkania): Document how to add to/modify these tests.
 class GpuPixelBrowserTest : public InProcessBrowserTest {
  public:
   GpuPixelBrowserTest()
       : ref_img_revision_(0),
         ref_img_revision_no_older_than_(0),
-        use_checked_in_ref_imgs_(false) {
+        ref_img_option_(kReferenceImageNone) {
   }
 
   virtual void SetUpCommandLine(CommandLine* command_line) {
     command_line->AppendSwitchASCII(switches::kTestGLLib,
                                     "libllvmpipe.so");
   }
 
   virtual void SetUpInProcessBrowserTestFixture() {
     InProcessBrowserTest::SetUpInProcessBrowserTestFixture();
 
+    CommandLine* command_line = CommandLine::ForCurrentProcess();
+    if (command_line->HasSwitch(switches::kUseGpuInTests))
+      ref_img_option_ = kReferenceImageLocal;
+
     ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &test_data_dir_));
     test_data_dir_ = test_data_dir_.AppendASCII("gpu");
 
-    CommandLine* command_line = CommandLine::ForCurrentProcess();
     if (command_line->HasSwitch(kGeneratedDir))
       generated_img_dir_ = command_line->GetSwitchValuePath(kGeneratedDir);
     else
       generated_img_dir_ = test_data_dir_.AppendASCII("generated");
-    if (command_line->HasSwitch(kReferenceDir))
-      ref_img_dir_ = command_line->GetSwitchValuePath(kReferenceDir);
-    else if (!command_line->HasSwitch(switches::kUseGpuInTests))
-      ref_img_dir_ = test_data_dir_.AppendASCII("llvmpipe_reference");
-    else
-      ref_img_dir_ = test_data_dir_.AppendASCII("gpu_reference");
 
-    // Only use checked in ref images when using a software rasterizer as
-    // all machines should generate the same output with a software rasterizer.
-    use_checked_in_ref_imgs_ = !command_line->HasSwitch(
-        switches::kUseGpuInTests);
+    switch (ref_img_option_) {
+      case kReferenceImageLocal:
+        if (command_line->HasSwitch(kReferenceDir))
+          ref_img_dir_ = command_line->GetSwitchValuePath(kReferenceDir);
+        else
+          ref_img_dir_ = test_data_dir_.AppendASCII("gpu_reference");
+        break;
+      case kReferenceImageCheckedIn:
+        ref_img_dir_ = test_data_dir_.AppendASCII("llvmpipe_reference");
+        break;
+      default:
+        break;
+    }
 
     test_name_ = testing::UnitTest::GetInstance()->current_test_info()->name();
     const char* test_status_prefixes[] = {"DISABLED_", "FLAKY_", "FAILS_"};
     for (size_t i = 0; i < arraysize(test_status_prefixes); ++i) {
       ReplaceFirstSubstringAfterOffset(
           &test_name_, 0, test_status_prefixes[i], "");
     }
 
     ui::DisableTestCompositor();
   }
 
   // If the existing ref image was saved from an revision older than the
   // ref_img_update_revision, refresh the ref image.
   void RunPixelTest(const gfx::Size& tab_container_size,
                     const FilePath& url,
-                    int64 ref_img_update_revision) {
-    if (!use_checked_in_ref_imgs_) {
+                    int64 ref_img_update_revision,
+                    const ReferencePixel* ref_pixels,
+                    size_t ref_pixel_count) {
+    if (ref_img_option_ == kReferenceImageLocal) {
       ref_img_revision_no_older_than_ = ref_img_update_revision;
       ObtainLocalRefImageRevision();
     }
 
 #if defined(OS_WIN)
     ASSERT_TRUE(tracing::BeginTracing("-test_*"));
 #endif
 
     ASSERT_TRUE(ui_test_utils::BringBrowserWindowToFront(browser()));
 
@@ skipping 27 matching lines @@
     }
 
     bool ignore_bottom_corners = false;
 #if defined(OS_MACOSX)
     // On Mac Lion, bottom corners have shadows with random pixels.
     ignore_bottom_corners = true;
 #endif
 
     SkBitmap bitmap;
     ASSERT_TRUE(TabSnapShotToImage(&bitmap));
-    bool is_image_same = CompareImages(bitmap, ignore_bottom_corners);
-    EXPECT_TRUE(is_image_same);
+    bool same_pixels = true;
+    if (ref_img_option_ == kReferenceImageNone && ref_pixels && ref_pixel_count)
+      same_pixels = ComparePixels(bitmap, ref_pixels, ref_pixel_count);
+    else
+      same_pixels = CompareImages(bitmap, ignore_bottom_corners);
+    EXPECT_TRUE(same_pixels);
 
 #if defined(OS_WIN)
     // For debugging the flaky test, this prints out a trace of what happened on
     // failure.
     std::string trace_events;
     ASSERT_TRUE(tracing::EndTracing(&trace_events));
-    if (!is_image_same)
+    if (!same_pixels)
       fprintf(stderr, "\n\nTRACE JSON:\n\n%s\n\n", trace_events.c_str());
 #endif
   }
 
   const FilePath& test_data_dir() const {
     return test_data_dir_;
   }
 
  private:
   FilePath test_data_dir_;
   FilePath generated_img_dir_;
   FilePath ref_img_dir_;
   int64 ref_img_revision_;
   // The name of the test, with any special prefixes dropped.
   std::string test_name_;
 
   // Any local ref image generated from older revision is ignored.
   int64 ref_img_revision_no_older_than_;
 
-  // If true, the test will use checked in reference images.
-  bool use_checked_in_ref_imgs_;
+  // Whether use locally generated ref images, or checked in ref images, or
+  // simply check a few key pixels.
+  ReferenceImageOption ref_img_option_;
 
   // Compares the generated bitmap with the appropriate reference image on disk.
   // Returns true iff the images were the same.
   //
   // If no valid reference image exists, save the generated bitmap to the disk.
   // The image format is:
   //     <test_name>_<revision>.png
   // E.g.,
   //     WebGLTeapot_19762.png
   // The number is the chromium revision that generated the image.
   //
   // On failure or on ref image generation, the image and diff image will be
   // written to disk. The formats are:
   //     FAIL_<ref_image_name>, DIFF_<ref_image_name>
   // E.g.,
   //     FAIL_WebGLTeapot_19762.png, DIFF_WebGLTeapot_19762.png
   bool CompareImages(const SkBitmap& gen_bmp, bool skip_bottom_corners) {
     SkBitmap ref_bmp_on_disk;
 
     FilePath img_path = ref_img_dir_.AppendASCII(test_name_ + ".png");
     bool found_ref_img = ReadPNGFile(img_path, &ref_bmp_on_disk);
 
-    if (!found_ref_img && use_checked_in_ref_imgs_) {
+    if (!found_ref_img && ref_img_option_ == kReferenceImageCheckedIn) {
       LOG(ERROR) << "Couldn't find reference image: "
                  << img_path.value();
       // No image to compare to, exit early.
       return false;
     }
 
     const SkBitmap* ref_bmp;
     bool save_gen = false;
     bool save_diff = true;
     bool rt = true;
 
-    if ((ref_img_revision_ <= 0 && !use_checked_in_ref_imgs_) ||
+    if ((ref_img_revision_ <= 0 && ref_img_option_ == kReferenceImageLocal) ||
         !found_ref_img) {
       chrome::VersionInfo chrome_version_info;
       FilePath rev_path = ref_img_dir_.AppendASCII(
           test_name_ + "_" + chrome_version_info.LastChange() + ".rev");
       if (!WritePNGFile(gen_bmp, img_path)) {
         LOG(ERROR) << "Can't save generated image to: "
                    << img_path.value()
                    << " as future reference.";
         rt = false;
       } else {
@@ skipping 27 matching lines @@
     }
 
     SkBitmap diff_bmp;
     if (ref_bmp->width() != gen_bmp.width() ||
         ref_bmp->height() != gen_bmp.height()) {
       LOG(ERROR)
           << "Dimensions do not match (Expected) vs (Actual):"
           << "(" << ref_bmp->width() << "x" << ref_bmp->height()
               << ") vs. "
           << "(" << gen_bmp.width() << "x" << gen_bmp.height() << ")";
-      if (!use_checked_in_ref_imgs_)
+      if (ref_img_option_ == kReferenceImageLocal)
         save_gen = true;
       rt = false;
     } else {
       // Compare pixels and create a simple diff image.
       int diff_pixels_count = 0;
       diff_bmp.setConfig(SkBitmap::kARGB_8888_Config,
                          gen_bmp.width(), gen_bmp.height());
       diff_bmp.allocPixels();
       diff_bmp.eraseColor(SK_ColorWHITE);
       SkAutoLockPixels lock_bmp(gen_bmp);
@@ skipping 14 matching lines @@
           if ((*gen_bmp.getAddr32(x, y) & kAlphaMask) !=
               (*ref_bmp->getAddr32(x, y) & kAlphaMask)) {
             ++diff_pixels_count;
             *diff_bmp.getAddr32(x, y) = 192 << 16;  // red
           }
         }
       }
       if (diff_pixels_count > 0) {
         LOG(ERROR) << diff_pixels_count
                    << " pixels do not match.";
-        if (!use_checked_in_ref_imgs_) {
+        if (ref_img_option_ == kReferenceImageLocal) {
           save_gen = true;
           save_diff = true;
         }
         rt = false;
       }
     }
 
     std::string ref_img_filename = img_path.BaseName().MaybeAsASCII();
     if (save_gen) {
       FilePath img_fail_path = generated_img_dir_.AppendASCII(
@@ skipping 13 matching lines @@
         LOG(ERROR) << "Can't save generated diff image to: "
                    << img_diff_path.value();
       } else {
         LOG(INFO) << "Saved difference image to: "
                   << img_diff_path.value();
       }
     }
     return rt;
   }
 
+  bool ComparePixels(const SkBitmap& gen_bmp,
+                     const ReferencePixel* ref_pixels,
+                     size_t ref_pixel_count) {
+    SkAutoLockPixels lock_bmp(gen_bmp);
+
+    for (size_t i = 0; i < ref_pixel_count; ++i) {
+      int x = ref_pixels[i].x;
+      int y = ref_pixels[i].y;
+      unsigned char r = ref_pixels[i].r;
+      unsigned char g = ref_pixels[i].g;
+      unsigned char b = ref_pixels[i].b;
+
+      DCHECK(x >= 0 && x < gen_bmp.width() && y >= 0 && y < gen_bmp.height());
+
+      unsigned char* rgba = reinterpret_cast<unsigned char*>(
+          gen_bmp.getAddr32(x, y));
+      DCHECK(rgba);
+      if (rgba[0] != b || rgba[1] != g || rgba[2] != r) {
+        std::string error_message = base::StringPrintf(
+            "pixel(%d,%d) expects [%u,%u,%u], but gets [%u,%u,%u] instead",
+            x, y, r, g, b, rgba[0], rgba[1], rgba[2]);
+        LOG(ERROR) << error_message.c_str();
+        return false;
+      }
+    }
+    return true;
+  }
+
   // Returns a gfx::Rect representing the bounds that the browser window should
   // have if the tab contents have the desired size.
   gfx::Rect GetNewTabContainerBounds(const gfx::Size& desired_size) {
     gfx::Rect container_rect;
     chrome::GetActiveWebContents(browser())->GetContainerBounds(&container_rect);
     // Size cannot be negative, so use a point.
     gfx::Point correction(
         desired_size.width() - container_rect.size().width(),
         desired_size.height() - container_rect.size().height());
 
@@ skipping 82 matching lines @@
 #define MAYBE_CSS3DBlueBox FLAKY_CSS3DBlueBox
 #else
 #define MAYBE_CSS3DBlueBox CSS3DBlueBox
 #endif
 
 IN_PROC_BROWSER_TEST_F(GpuPixelBrowserTest, MAYBE_WebGLGreenTriangle) {
   // If test baseline needs to be updated after a given revision, update the
   // following number. If no revision requirement, then 0.
   const int64 ref_img_revision_update = 123489;
 
+  const ReferencePixel ref_pixels[] = {
+    // x, y, r, g, b
+    {50, 100, 0, 0, 0},
+    {100, 100, 0, 255, 0},
+    {150, 100, 0, 0, 0},
+    {50, 150, 0, 255, 0},
+    {100, 150, 0, 255, 0},
+    {150, 150, 0, 255, 0}
+  };
+  const size_t ref_pixel_count = sizeof(ref_pixels) / sizeof(ReferencePixel);
+
   gfx::Size container_size(400, 300);
   FilePath url =
       test_data_dir().AppendASCII("pixel_webgl.html");
-  RunPixelTest(container_size, url, ref_img_revision_update);
+  RunPixelTest(container_size, url, ref_img_revision_update,
+               ref_pixels, ref_pixel_count);
 }
 
 IN_PROC_BROWSER_TEST_F(GpuPixelBrowserTest, MAYBE_CSS3DBlueBox) {
   // If test baseline needs to be updated after a given revision, update the
   // following number. If no revision requirement, then 0.
   const int64 ref_img_revision_update = 123489;
 
+  const ReferencePixel ref_pixels[] = {
+    // x, y, r, g, b
+    {70, 50, 0, 0, 255},
+    {150, 50, 0, 0, 0},
+    {70, 90, 0, 0, 255},
+    {150, 90, 0, 0, 255},
+    {70, 125, 0, 0, 255},
+    {150, 125, 0, 0, 0}
+  };
+  const size_t ref_pixel_count = sizeof(ref_pixels) / sizeof(ReferencePixel);
+
   gfx::Size container_size(400, 300);
   FilePath url =
       test_data_dir().AppendASCII("pixel_css3d.html");
-  RunPixelTest(container_size, url, ref_img_revision_update);
+  RunPixelTest(container_size, url, ref_img_revision_update,
+               ref_pixels, ref_pixel_count);
 }
 
 IN_PROC_BROWSER_TEST_F(GpuPixelBrowserTest, Canvas2DRedBoxHD) {
   // If test baseline needs to be updated after a given revision, update the
   // following number. If no revision requirement, then 0.
   const int64 ref_img_revision_update = 123489;
 
+  const ReferencePixel ref_pixels[] = {
+    // x, y, r, g, b
+    {40, 100, 0, 0, 0},
+    {60, 100, 127, 0, 0},
+    {140, 100, 127, 0, 0},
+    {160, 100, 0, 0, 0}
+  };
+  const size_t ref_pixel_count = sizeof(ref_pixels) / sizeof(ReferencePixel);
+
   gfx::Size container_size(400, 300);
   FilePath url =
       test_data_dir().AppendASCII("pixel_canvas2d.html");
-  RunPixelTest(container_size, url, ref_img_revision_update);
+  RunPixelTest(container_size, url, ref_img_revision_update,
+               ref_pixels, ref_pixel_count);
 }
 
 class Canvas2DPixelTestSD : public GpuPixelBrowserTest {
  public:
   virtual void SetUpCommandLine(CommandLine* command_line) {
     GpuPixelBrowserTest::SetUpCommandLine(command_line);
     command_line->AppendSwitch(switches::kDisableAccelerated2dCanvas);
   }
 };
 
 IN_PROC_BROWSER_TEST_F(Canvas2DPixelTestSD, Canvas2DRedBoxSD) {
   // If test baseline needs to be updated after a given revision, update the
   // following number. If no revision requirement, then 0.
   const int64 ref_img_revision_update = 123489;
 
+  const ReferencePixel ref_pixels[] = {
+    // x, y, r, g, b
+    {40, 100, 0, 0, 0},
+    {60, 100, 127, 0, 0},
+    {140, 100, 127, 0, 0},
+    {160, 100, 0, 0, 0}
+  };
+  const size_t ref_pixel_count = sizeof(ref_pixels) / sizeof(ReferencePixel);
+
   gfx::Size container_size(400, 300);
   FilePath url =
       test_data_dir().AppendASCII("pixel_canvas2d.html");
-  RunPixelTest(container_size, url, ref_img_revision_update);
+  RunPixelTest(container_size, url, ref_img_revision_update,
+               ref_pixels, ref_pixel_count);
 }