Fix gfx::Canvas::DrawStringRectWithHalo

ui/compositor/layer_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 "ui/compositor/layer.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
+#include "base/strings/utf_string_conversions.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/layers/layer.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/output/copy_output_result.h"
 #include "cc/surfaces/surface_id.h"
 #include "cc/surfaces/surface_sequence.h"
 #include "cc/test/pixel_test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/compositor/compositor_observer.h"
 #include "ui/compositor/dip_util.h"
 #include "ui/compositor/layer_animation_element.h"
 #include "ui/compositor/layer_animation_observer.h"
 #include "ui/compositor/layer_animation_sequence.h"
 #include "ui/compositor/layer_animator.h"
 #include "ui/compositor/paint_context.h"
 #include "ui/compositor/paint_recorder.h"
 #include "ui/compositor/scoped_animation_duration_scale_mode.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/compositor/test/context_factories_for_test.h"
 #include "ui/compositor/test/draw_waiter_for_test.h"
 #include "ui/compositor/test/test_compositor_host.h"
 #include "ui/compositor/test/test_layers.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/codec/png_codec.h"
+#include "ui/gfx/font_list.h"
 #include "ui/gfx/gfx_paths.h"
 #include "ui/gfx/skia_util.h"
 
 using cc::MatchesPNGFile;
+using cc::WritePNGFile;
 
 namespace ui {
 
 namespace {
 
 // There are three test classes in here that configure the Compositor and
 // Layer's slightly differently:
 // - LayerWithNullDelegateTest uses NullLayerDelegate as the LayerDelegate. This
 //   is typically the base class you want to use.
 // - LayerWithDelegateTest uses LayerDelegate on the delegates.
@@ skipping 22 matching lines @@
   void OnDeviceScaleFactorChanged(float device_scale_factor) override {}
 
   base::Closure PrepareForLayerBoundsChange() override {
     return base::Closure();
   }
 
  private:
   SkColor color_;
 };
 
+class DrawStringLayerDelegate: public LayerDelegate {
+ public:
+  enum DrawFunction {
+    STRING_WITH_HALO,
+    STRING_FADED,
+    STRING_WITH_SHADOWS
+  };
+
+  DrawStringLayerDelegate(
+      SkColor back_color, SkColor halo_color, DrawFunction func)
+      : background_color_(back_color),
+        halo_color_(halo_color),
+        func_(func) {
+  }
+
+  ~DrawStringLayerDelegate() override {}
+
+  void set_layer_size(const gfx::Size& layer_size) {
+    layer_size_ = layer_size;
+  }
+
+  // Overridden from LayerDelegate:
+  void OnPaintLayer(const ui::PaintContext& context) override {
+    ui::PaintRecorder recorder(context, layer_size_);
+    gfx::Rect bounds(layer_size_);
+    recorder.canvas()->DrawColor(background_color_);
+    const base::string16 text = base::ASCIIToUTF16("Tests!");
+    switch (func_) {
+      case STRING_WITH_HALO:
+        recorder.canvas()->DrawStringRectWithHalo(
+            text, font_list_, SK_ColorRED, halo_color_, bounds, 0);
+        break;
+      case STRING_FADED:
+        recorder.canvas()->DrawFadedString(
+            text, font_list_, SK_ColorRED, bounds, 0);
+        break;
+      case STRING_WITH_SHADOWS: {
+        gfx::ShadowValues shadows;
+        shadows.push_back(
+            gfx::ShadowValue(gfx::Vector2d(2, 2), 2, SK_ColorRED));
+        recorder.canvas()->DrawStringRectWithShadows(
+            text, font_list_, SK_ColorRED, bounds, 0, 0, shadows);
+        break;
+      }
+      default:
+        NOTREACHED();
+    }
+  }
+
+  void OnDelegatedFrameDamage(const gfx::Rect& damage_rect_in_dip) override {}
+
+  void OnDeviceScaleFactorChanged(float device_scale_factor) override {}
+
+  base::Closure PrepareForLayerBoundsChange() override {
+    return base::Closure();
+  }
+
+ private:
+  SkColor background_color_;
+  SkColor halo_color_;
+  DrawFunction func_;
+  gfx::FontList font_list_;
+  gfx::Size layer_size_;
+};
+
 class LayerWithRealCompositorTest : public testing::Test {
  public:
   LayerWithRealCompositorTest() {
     if (PathService::Get(gfx::DIR_TEST_DATA, &test_data_directory_)) {
       test_data_directory_ = test_data_directory_.AppendASCII("compositor");
     } else {
       LOG(ERROR) << "Could not open test data directory.";
     }
+    gfx::FontList::SetDefaultFontDescription("Arial, Times New Roman, 15px");
   }
   ~LayerWithRealCompositorTest() override {}
 
   // Overridden from testing::Test:
   void SetUp() override {
     bool enable_pixel_output = true;
     ui::ContextFactory* context_factory =
         InitializeContextFactoryForTests(enable_pixel_output);
 
     const gfx::Rect host_bounds(10, 10, 500, 500);
@@ skipping 22 matching lines @@
     layer->SetBounds(bounds);
     return layer;
   }
 
   Layer* CreateNoTextureLayer(const gfx::Rect& bounds) {
     Layer* layer = CreateLayer(LAYER_NOT_DRAWN);
     layer->SetBounds(bounds);
     return layer;
   }
 
+  Layer* CreateDrawStringLayer(const gfx::Rect& bounds,
+                               DrawStringLayerDelegate* delegate) {
+    Layer* layer = new Layer(LAYER_TEXTURED);
+    layer->SetBounds(bounds);
+    delegate->set_layer_size(layer->size());
+    layer->set_delegate(delegate);
+    return layer;
+  }
+
   void DrawTree(Layer* root) {
     GetCompositor()->SetRootLayer(root);
     GetCompositor()->ScheduleDraw();
     WaitForSwap();
   }
 
   void ReadPixels(SkBitmap* bitmap) {
     ReadPixels(bitmap, gfx::Rect(GetCompositor()->size()));
   }
 
@@ skipping 1068 matching lines @@
   EXPECT_TRUE(MatchesPNGFile(bitmap, ref_img1, cc::ExactPixelComparator(true)));
 
   // l11 back to front
   l0->StackAbove(l11.get(), l12.get());
   DrawTree(l0.get());
   ReadPixels(&bitmap);
   ASSERT_FALSE(bitmap.empty());
   EXPECT_TRUE(MatchesPNGFile(bitmap, ref_img2, cc::ExactPixelComparator(true)));
 }
 
+TEST_F(LayerWithRealCompositorTest, CanvasDrawStringRectWithHalo) {
+  gfx::Size size(50, 50);
+  GetCompositor()->SetScaleAndSize(1.0f, size);
+  DrawStringLayerDelegate delegate(SK_ColorBLUE, SK_ColorWHITE,
+                                   DrawStringLayerDelegate::STRING_WITH_HALO);
+  std::unique_ptr<Layer> layer(
+      CreateDrawStringLayer(gfx::Rect(size), &delegate));
+  DrawTree(layer.get());
+
+  SkBitmap bitmap;
+  ReadPixels(&bitmap);
+  ASSERT_FALSE(bitmap.empty());
+
+  base::FilePath ref_img =
+      test_data_directory().AppendASCII("string_with_halo.png");
+  // WritePNGFile(bitmap, ref_img, true);
+
+#if defined(OS_WIN)
+  float percentage_pixels_large_error = 10.0f;  // 250px / (50*50)
+#else
+  float percentage_pixels_large_error = 50.0f;  // Don't check.

[danakj, 2016/06/01 18:45:47]

What do you mean don't check? Surely the platform where you're generating the
pngs doesn't need any error allowance? Normally we generate pngs on linux, and
so we'd get exact results there, and allow some pixels to differ on other
platforms.

[danakj, 2016/06/22 23:14:03]

OK then just #ifdef windows around the whole test, no point in running the test
and not doing anything in it.

I think this is better than nothing and don't want to see this go around a lot
more rounds.

LGTM with a few more comments.

+#endif // defined(OS_WIN)
+  float percentage_pixels_small_error = 0.0f;
+  float average_error_allowed_in_bad_pixels = 256.f;
+  int large_error_allowed = 256;

[danakj, 2016/06/22 23:14:03]

Can you narrow this? Surely the pixels are off by only a little in each channel.
The test output will actually say the maximum error amount in each of r/g/b when
it fails, so you can use that to choose the minimum needed.

Same for the average allowed, it prints out in a failure what it found so you
can use something close to that instead?

Ditto for the other test.

+  int small_error_allowed = 0;
+
+  EXPECT_TRUE(MatchesPNGFile(bitmap, ref_img,
+                             cc::FuzzyPixelComparator(
+                                 true,
+                                 percentage_pixels_large_error,
+                                 percentage_pixels_small_error,
+                                 average_error_allowed_in_bad_pixels,
+                                 large_error_allowed,
+                                 small_error_allowed)));
+}
+
+TEST_F(LayerWithRealCompositorTest, CanvasDrawFadedString) {
+  gfx::Size size(50, 50);
+  GetCompositor()->SetScaleAndSize(1.0f, size);
+  DrawStringLayerDelegate delegate(SK_ColorBLUE, SK_ColorWHITE,
+                                   DrawStringLayerDelegate::STRING_FADED);
+  std::unique_ptr<Layer> layer(
+      CreateDrawStringLayer(gfx::Rect(size), &delegate));
+  DrawTree(layer.get());
+
+  SkBitmap bitmap;
+  ReadPixels(&bitmap);
+  ASSERT_FALSE(bitmap.empty());
+
+  base::FilePath ref_img =
+      test_data_directory().AppendASCII("string_faded.png");
+  // WritePNGFile(bitmap, ref_img, true);
+
+#if defined(OS_WIN)
+  float percentage_pixels_large_error = 15.0f;  // 375px / (50*50)
+#else
+  float percentage_pixels_large_error = 50.0f;  // Don't check.
+#endif // defined(OS_WIN)
+  float percentage_pixels_small_error = 0.0f;
+  float average_error_allowed_in_bad_pixels = 256.f;
+  int large_error_allowed = 256;
+  int small_error_allowed = 0;
+
+  EXPECT_TRUE(MatchesPNGFile(bitmap, ref_img,
+                             cc::FuzzyPixelComparator(
+                                 true,
+                                 percentage_pixels_large_error,
+                                 percentage_pixels_small_error,
+                                 average_error_allowed_in_bad_pixels,
+                                 large_error_allowed,
+                                 small_error_allowed)));
+}
+
+TEST_F(LayerWithRealCompositorTest, CanvasDrawStringRectWithShadows) {
+  gfx::Size size(50, 50);
+  GetCompositor()->SetScaleAndSize(1.0f, size);
+  DrawStringLayerDelegate delegate(
+      SK_ColorBLUE, SK_ColorWHITE,
+      DrawStringLayerDelegate::STRING_WITH_SHADOWS);
+  std::unique_ptr<Layer> layer(
+      CreateDrawStringLayer(gfx::Rect(size), &delegate));
+  DrawTree(layer.get());
+
+  SkBitmap bitmap;
+  ReadPixels(&bitmap);
+  ASSERT_FALSE(bitmap.empty());
+
+  base::FilePath ref_img =
+      test_data_directory().AppendASCII("string_with_shadows.png");
+  // WritePNGFile(bitmap, ref_img, true);
+
+#if defined(OS_WIN)
+  float percentage_pixels_large_error = 20.0f;  // 500px / (50*50)
+#else
+  float percentage_pixels_large_error = 50.0f;  // Don't check.
+#endif // defined(OS_WIN)
+  float percentage_pixels_small_error = 0.0f;
+  float average_error_allowed_in_bad_pixels = 256.f;
+  int large_error_allowed = 256;
+  int small_error_allowed = 0;
+
+  EXPECT_TRUE(MatchesPNGFile(bitmap, ref_img,
+                             cc::FuzzyPixelComparator(
+                                 true,
+                                 percentage_pixels_large_error,
+                                 percentage_pixels_small_error,
+                                 average_error_allowed_in_bad_pixels,
+                                 large_error_allowed,
+                                 small_error_allowed)));
+}
+
 // Opacity is rendered correctly.
 // Checks that modifying the hierarchy correctly affects final composite.
 TEST_F(LayerWithRealCompositorTest, Opacity) {
   GetCompositor()->SetScaleAndSize(1.0f, gfx::Size(50, 50));
 
   // l0
   //  +-l11
   std::unique_ptr<Layer> l0(
       CreateColorLayer(SK_ColorRED, gfx::Rect(0, 0, 50, 50)));
   std::unique_ptr<Layer> l11(
@@ skipping 636 matching lines @@
   root->SetOpacity(0.5f);
   WaitForSwap();
   EXPECT_EQ(1u, animation_observer.animation_step_count());
 
   EXPECT_FALSE(animation_observer.shutdown());
   ResetCompositor();
   EXPECT_TRUE(animation_observer.shutdown());
 }
 
 }  // namespace ui