Revert of [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());
-}
-
-bool ColorsMatchWithinLimit(SkColor color1,
-                            SkColor color2,
-                            int32_t error_limit) {
-  auto a_distance = std::abs(static_cast<int32_t>(SkColorGetA(color1)) -
-                             static_cast<int32_t>(SkColorGetA(color2)));
-  auto r_distance = std::abs(static_cast<int32_t>(SkColorGetR(color1)) -
-                             static_cast<int32_t>(SkColorGetR(color2)));
-  auto g_distance = std::abs(static_cast<int32_t>(SkColorGetG(color1)) -
-                             static_cast<int32_t>(SkColorGetG(color2)));
-  auto b_distance = std::abs(static_cast<int32_t>(SkColorGetB(color1)) -
-                             static_cast<int32_t>(SkColorGetB(color2)));
-
-  return a_distance * a_distance + r_distance * r_distance +
-             g_distance * g_distance + b_distance * b_distance <=
-         error_limit * error_limit;
-}
-
 // Adapted from cc::ExactPixelComparator.
 bool MatchesBitmap(const SkBitmap& expected_bmp,
                    const SkBitmap& actual_bmp,
-                   const gfx::Rect& matching_mask,
-                   int error_limit) {
+                   const gfx::Rect& matching_mask) {
   // 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 (!ColorsMatchWithinLimit(actual_color, expected_color, error_limit)) {
+      if (actual_color != expected_color) {
         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:
-  enum ScreenshotEncoding { ENCODING_PNG, ENCODING_JPEG };
-  void CaptureScreenshotAndCompareTo(const SkBitmap& expected_bitmap,
-                                     ScreenshotEncoding encoding) {
-    std::unique_ptr<base::DictionaryValue> params(new base::DictionaryValue());
-    params->SetString("format", encoding == ENCODING_PNG ? "png" : "jpeg");
-    params->SetInteger("quality", 100);
-    SendCommand("Page.captureScreenshot", std::move(params));
-
+  void CaptureScreenshotAndCompareTo(const SkBitmap& expected_bitmap) {
+    SendCommand("Page.captureScreenshot", nullptr);
     std::string base64;
     EXPECT_TRUE(result_->GetString("data", &base64));
-    std::unique_ptr<SkBitmap> result_bitmap;
-    int error_limit = 0;
-    if (encoding == ENCODING_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);
-
+    SkBitmap result_bitmap;
+    EXPECT_TRUE(DecodePNG(base64, &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,
-                              error_limit));
+    EXPECT_TRUE(MatchesBitmap(expected_bitmap, result_bitmap, matching_mask));
   }
 
   // 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, ENCODING_PNG);
+    CaptureScreenshotAndCompareTo(expected_bitmap);
 
     // 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);
   }
 #endif
 };
 
 IN_PROC_BROWSER_TEST_F(CaptureScreenshotTest, CaptureScreenshot) {
   // This test fails consistently on low-end Android devices.
   // See crbug.com/653637.
-  // TODO(eseckler): Reenable with error limit if necessary.
   if (base::SysInfo::IsLowEndDevice()) return;
 
-  shell()->LoadURL(
-      GURL("data:text/html,<body style='background:#123456'></body>"));
-  WaitForLoadStop(shell()->web_contents());
+  shell()->LoadURL(GURL("about:blank"));
   Attach();
+  EXPECT_TRUE(
+      content::ExecuteScript(shell()->web_contents()->GetRenderViewHost(),
+                             "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, ENCODING_PNG);
-}
-
-IN_PROC_BROWSER_TEST_F(CaptureScreenshotTest, CaptureScreenshotJpeg) {
-  // This test fails consistently on low-end Android devices.
-  // See crbug.com/653637.
-  // TODO(eseckler): Reenable with error limit if necessary.
-  if (base::SysInfo::IsLowEndDevice())
-    return;
-
-  shell()->LoadURL(
-      GURL("data:text/html,<body style='background:#123456'></body>"));
-  WaitForLoadStop(shell()->web_contents());
-  Attach();
-  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, ENCODING_JPEG);
+  CaptureScreenshotAndCompareTo(expected_bitmap);
 }
 
 // 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