[devtools] Support different encodings for Page.CaptureScreenshot.

content/browser/devtools/protocol/devtools_protocol_browsertest.cc

 // Copyright 2013 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 <utility>
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 31 matching lines @@
 #include "content/test/content_browser_test_utils_internal.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/test/cert_test_util.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "net/test/test_data_directory.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/base/layout.h"
 #include "ui/compositor/compositor_switches.h"
+#include "ui/gfx/codec/jpeg_codec.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/skia_util.h"
+#include "ui/snapshot/snapshot.h"
 
 #define EXPECT_SIZE_EQ(expected, actual)               \
   do {                                                 \
     EXPECT_EQ((expected).width(), (actual).width());   \
     EXPECT_EQ((expected).height(), (actual).height()); \
   } while (false)
 
 using testing::ElementsAre;
 
 namespace content {
@@ skipping 391 matching lines @@
 namespace {
 bool DecodePNG(std::string base64_data, SkBitmap* bitmap) {
   std::string png_data;
   if (!base::Base64Decode(base64_data, &png_data))
     return false;
   return gfx::PNGCodec::Decode(
       reinterpret_cast<unsigned const char*>(png_data.data()), png_data.size(),
       bitmap);
 }
 
+std::unique_ptr<SkBitmap> DecodeJPEG(std::string base64_data) {
+  std::string jpeg_data;
+  if (!base::Base64Decode(base64_data, &jpeg_data))
+    return nullptr;
+  return gfx::JPEGCodec::Decode(
+      reinterpret_cast<unsigned const char*>(jpeg_data.data()),
+      jpeg_data.size());
+}
+
 // Adapted from cc::ExactPixelComparator.
 bool MatchesBitmap(const SkBitmap& expected_bmp,
                    const SkBitmap& actual_bmp,
-                   const gfx::Rect& matching_mask) {
+                   const gfx::Rect& matching_mask,
+                   int error_limit) {
   // Number of pixels with an error
   int error_pixels_count = 0;
 
   gfx::Rect error_bounding_rect = gfx::Rect();
 
   // Check that bitmaps have identical dimensions.
   EXPECT_EQ(expected_bmp.width(), actual_bmp.width());
   EXPECT_EQ(expected_bmp.height(), actual_bmp.height());
   if (expected_bmp.width() != actual_bmp.width() ||
       expected_bmp.height() != actual_bmp.height()) {
     return false;
   }
 
   SkAutoLockPixels lock_actual_bmp(actual_bmp);
   SkAutoLockPixels lock_expected_bmp(expected_bmp);
 
   DCHECK(gfx::SkIRectToRect(actual_bmp.bounds()).Contains(matching_mask));
 
   for (int x = matching_mask.x(); x < matching_mask.width(); ++x) {
     for (int y = matching_mask.y(); y < matching_mask.height(); ++y) {
       SkColor actual_color = actual_bmp.getColor(x, y);
       SkColor expected_color = expected_bmp.getColor(x, y);
-      if (actual_color != expected_color) {
+      if (std::abs(static_cast<int32_t>(actual_color) -
+                   static_cast<int32_t>(expected_color)) > error_limit) {
         if (error_pixels_count < 10) {
           LOG(ERROR) << "Pixel (" << x << "," << y << "): expected "
                      << expected_color << " actual " << actual_color;
         }
         error_pixels_count++;
         error_bounding_rect.Union(gfx::Rect(x, y, 1, 1));
       }
     }
   }
 
   if (error_pixels_count != 0) {
     LOG(ERROR) << "Number of pixel with an error: " << error_pixels_count;
     LOG(ERROR) << "Error Bounding Box : " << error_bounding_rect.ToString();
     return false;
   }
 
   return true;
 }
 }  // namespace
 
 class CaptureScreenshotTest : public DevToolsProtocolTest {
  protected:
-  void CaptureScreenshotAndCompareTo(const SkBitmap& expected_bitmap) {
-    SendCommand("Page.captureScreenshot", nullptr);
+  void CaptureScreenshotAndCompareTo(const SkBitmap& expected_bitmap,
+                                     ui::SnapshotEncoding encoding) {
+    std::unique_ptr<base::DictionaryValue> params(new base::DictionaryValue());
+    params->SetString("format",
+                      encoding == ui::SnapshotEncoding::PNG ? "png" : "jpeg");
+    params->SetInteger("quality", 100);
+    SendCommand("Page.captureScreenshot", std::move(params));
+
     std::string base64;
     EXPECT_TRUE(result_->GetString("data", &base64));
-    SkBitmap result_bitmap;
-    EXPECT_TRUE(DecodePNG(base64, &result_bitmap));
+    std::unique_ptr<SkBitmap> result_bitmap;
+    int error_limit = 0;
+    if (encoding == ui::SnapshotEncoding::PNG) {
+      result_bitmap.reset(new SkBitmap());
+      EXPECT_TRUE(DecodePNG(base64, result_bitmap.get()));
+    } else {
+      result_bitmap = DecodeJPEG(base64);
+      // Even with quality 100, jpeg isn't lossless. So, we allow some skew in
+      // pixel values. Not that this assumes that there is no skew in pixel
+      // positions, so will only work reliably if all pixels have equal values.
+      error_limit = 3;
+    }
+    EXPECT_TRUE(result_bitmap);
+
     gfx::Rect matching_mask(gfx::SkIRectToRect(expected_bitmap.bounds()));
 #if defined(OS_MACOSX)
     // Mask out the corners, which may be drawn differently on Mac because of
     // rounded corners.
     matching_mask.Inset(4, 4, 4, 4);
 #endif
-    EXPECT_TRUE(MatchesBitmap(expected_bitmap, result_bitmap, matching_mask));
+    EXPECT_TRUE(MatchesBitmap(expected_bitmap, *result_bitmap, matching_mask,
+                              error_limit));
   }
 
   // Takes a screenshot of a colored box that is positioned inside the frame.
   void PlaceAndCaptureBox(const gfx::Size& frame_size,
                           const gfx::Size& box_size,
                           float screenshot_scale) {
     static const int kBoxOffsetHeight = 100;
     const gfx::Size scaled_box_size =
         ScaleToFlooredSize(box_size, screenshot_scale);
     std::unique_ptr<base::DictionaryValue> params;
@@ skipping 38 matching lines @@
     params->SetDouble("x", (frame_size.width() - box_size.width()) / 2.);
     params->SetDouble("y", kBoxOffsetHeight);
     params->SetDouble("scale", screenshot_scale);
     SendCommand("Emulation.forceViewport", std::move(params));
 
     // Capture screenshot and verify that it is indeed blue.
     SkBitmap expected_bitmap;
     expected_bitmap.allocN32Pixels(scaled_box_size.width(),
                                    scaled_box_size.height());
     expected_bitmap.eraseColor(SkColorSetRGB(0x00, 0x00, 0xff));
-    CaptureScreenshotAndCompareTo(expected_bitmap);
+    CaptureScreenshotAndCompareTo(expected_bitmap, ui::SnapshotEncoding::PNG);
 
     // Reset for next screenshot.
     SendCommand("Emulation.resetViewport", nullptr);
     SendCommand("Emulation.clearDeviceMetricsOverride", nullptr);
   }
 
  private:
 #if !defined(OS_ANDROID)
   void SetUpCommandLine(base::CommandLine* command_line) override {
     command_line->AppendSwitch(switches::kEnablePixelOutputInTests);
@@ skipping 13 matching lines @@
                              "document.body.style.background = '#123456'"));
   SkBitmap expected_bitmap;
   // We compare against the actual physical backing size rather than the
   // view size, because the view size is stored adjusted for DPI and only in
   // integer precision.
   gfx::Size view_size = static_cast<RenderWidgetHostViewBase*>(
                             shell()->web_contents()->GetRenderWidgetHostView())
                             ->GetPhysicalBackingSize();
   expected_bitmap.allocN32Pixels(view_size.width(), view_size.height());
   expected_bitmap.eraseColor(SkColorSetRGB(0x12, 0x34, 0x56));
-  CaptureScreenshotAndCompareTo(expected_bitmap);
+  CaptureScreenshotAndCompareTo(expected_bitmap, ui::SnapshotEncoding::PNG);
+}
+
+IN_PROC_BROWSER_TEST_F(CaptureScreenshotTest, CaptureScreenshotJpeg) {
+  // This test fails consistently on low-end Android devices.
+  // See crbug.com/653637.
+  if (base::SysInfo::IsLowEndDevice())
+    return;
+
+  shell()->LoadURL(GURL("about:blank"));
+  Attach();
+  EXPECT_TRUE(
+      content::ExecuteScript(shell()->web_contents()->GetRenderViewHost(),

[pfeldman, 2017/01/03 18:42:33]

I wonder if there is a theoretical race here - you are sending this info to the
renderer to be dispatched on main, while the screenshot is read natively in the
browser.

[Eric Seckler, 2017/01/03 19:18:09]

Hmm, I was under the impression that content::ExecuteScript waits for the result
of the script execution?

[pfeldman, 2017/01/04 00:10:50]

Oh, you are using the harness one. I looked at the RVH fetch and assumed it was
api call. You could still use following URL to avoid roundtrip:

data:text/html,<body style="background:#123456"></body>

[Eric Seckler, 2017/01/06 21:06:01]

Done :)

+                             "document.body.style.background = '#123456'"));
+  SkBitmap expected_bitmap;
+  // We compare against the actual physical backing size rather than the
+  // view size, because the view size is stored adjusted for DPI and only in
+  // integer precision.
+  gfx::Size view_size = static_cast<RenderWidgetHostViewBase*>(
+                            shell()->web_contents()->GetRenderWidgetHostView())
+                            ->GetPhysicalBackingSize();
+  expected_bitmap.allocN32Pixels(view_size.width(), view_size.height());
+  expected_bitmap.eraseColor(SkColorSetRGB(0x12, 0x34, 0x56));
+  CaptureScreenshotAndCompareTo(expected_bitmap, ui::SnapshotEncoding::JPEG);
 }
 
 // Setting frame size (through RWHV) is not supported on Android.
 #if defined(OS_ANDROID)
 #define MAYBE_CaptureScreenshotArea DISABLED_CaptureScreenshotArea
 #else
 #define MAYBE_CaptureScreenshotArea CaptureScreenshotArea
 #endif
 IN_PROC_BROWSER_TEST_F(CaptureScreenshotTest,
                        MAYBE_CaptureScreenshotArea) {
@@ skipping 875 matching lines @@
       EXPECT_EQ("polyglottal", value);
       found++;
     } else {
       FAIL();
     }
   }
   EXPECT_EQ(2u, found);
 }
 
 }  // namespace content