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 <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/scoped_ptr.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/delegated_frame_provider.h"
 #include "cc/layers/delegated_frame_resource_collection.h"
 #include "cc/layers/layer.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/output/copy_output_result.h"
 #include "cc/output/delegated_frame_data.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_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 DrawStringLayer : public Layer, public LayerDelegate {
+ public:
+  enum DrawFunction {
+    STRING_WITH_HALO,
+    STRING_FADED,
+    STRING_WITH_SHADOWS
+  };
+
+  DrawStringLayer(SkColor back_color, SkColor halo_color, DrawFunction func)
+      : Layer(LAYER_TEXTURED),
+        background_color_(back_color),
+        halo_color_(halo_color),
+        func_(func) {
+    set_delegate(this);
+  }
+
+  ~DrawStringLayer() override {}
+
+  // Overridden from LayerDelegate:
+  void OnPaintLayer(const ui::PaintContext& context) override {
+    ui::PaintRecorder recorder(context, size());
+    recorder.canvas()->DrawColor(background_color_);
+    const base::string16 text = base::ASCIIToUTF16("Danakj");
+    switch (func_) {
+      case STRING_WITH_HALO:
+        recorder.canvas()->DrawStringRectWithHalo(
+            text, font_list_, SK_ColorRED, halo_color_, gfx::Rect(size()), 0);
+        break;
+      case STRING_FADED:
+        recorder.canvas()->DrawFadedString(
+            text, font_list_, SK_ColorRED, gfx::Rect(size()), 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, gfx::Rect(size()), 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_;
+};
+
 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("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,
+                               SkColor background_color,
+                               SkColor halo_color,
+                               DrawStringLayer::DrawFunction func) {
+    Layer* layer = new DrawStringLayer(background_color, halo_color, func);
+    layer->SetBounds(bounds);
+    return layer;
+  }
+
   void DrawTree(Layer* root) {
     GetCompositor()->SetRootLayer(root);
     GetCompositor()->ScheduleDraw();
     WaitForSwap();
   }
 
   void ReadPixels(SkBitmap* bitmap) {
     ReadPixels(bitmap, gfx::Rect(GetCompositor()->size()));
   }
 
@@ skipping 35 matching lines @@
   // Invalidates the entire contents of the layer.
   void SchedulePaintForLayer(Layer* layer) {
     layer->SchedulePaint(
         gfx::Rect(0, 0, layer->bounds().width(), layer->bounds().height()));
   }
 
   const base::FilePath& test_data_directory() const {
     return test_data_directory_;
   }
 
+  bool CompareColor(const SkBitmap& bmp, const gfx::Size& size, SkColor color) {
+    SkBitmap ref_bmp;
+    ref_bmp.allocPixels(
+        SkImageInfo::MakeN32Premul(size.width(), size.height()));
+    SkCanvas canvas(ref_bmp);
+    canvas.clear(color);
+
+    cc::ExactPixelComparator comparator(true);
+    return comparator.Compare(bmp, ref_bmp);
+  }
+
+  bool HasColor(const SkBitmap& bitmap, const gfx::Size& size, SkColor color) {
+    SkAutoLockPixels lock(bitmap);
+    for (int x = 0; x < bitmap.width(); x++) {
+      for (int y = 0; y < bitmap.height(); y++) {
+        SkColor actual_color = bitmap.getColor(x, y);
+        if (actual_color == color) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
  private:
   class ReadbackHolder : public base::RefCountedThreadSafe<ReadbackHolder> {
    public:
     ReadbackHolder() : run_loop_(new base::RunLoop) {}
 
     void OutputRequestCallback(scoped_ptr<cc::CopyOutputResult> result) {
       result_ = result->TakeBitmap();
       run_loop_->Quit();
     }
 
@@ skipping 1006 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);
+  SkColor check_color = SK_ColorBLUE;
+  SkColor halo_color = SK_ColorWHITE;
+  GetCompositor()->SetScaleAndSize(1.0f, size);
+  scoped_ptr<Layer> layer(CreateDrawStringLayer(
+      gfx::Rect(size), check_color, halo_color,
+      DrawStringLayer::STRING_WITH_HALO));
+  DrawTree(layer.get());
+
+  SkBitmap bitmap;
+  ReadPixels(&bitmap);
+  ASSERT_FALSE(bitmap.empty());
+  ASSERT_EQ(50, bitmap.width());
+  ASSERT_EQ(50, bitmap.height());
+
+  EXPECT_FALSE(CompareColor(bitmap, size, check_color));
+  EXPECT_TRUE(HasColor(bitmap, size, halo_color));
+}
+
+TEST_F(LayerWithRealCompositorTest, CanvasDrawFadedString) {
+  gfx::Size size(50, 50);
+  SkColor check_color = SK_ColorBLUE;
+  SkColor halo_color = SK_ColorWHITE;
+  GetCompositor()->SetScaleAndSize(1.0f, size);
+  scoped_ptr<Layer> layer(CreateDrawStringLayer(
+      gfx::Rect(size), check_color, halo_color, DrawStringLayer::STRING_FADED));
+  DrawTree(layer.get());
+
+  SkBitmap bitmap;
+  ReadPixels(&bitmap);
+  ASSERT_FALSE(bitmap.empty());
+
+  EXPECT_FALSE(CompareColor(bitmap, size, check_color));
+  EXPECT_FALSE(HasColor(bitmap, size, halo_color));
+}
+
+TEST_F(LayerWithRealCompositorTest, CanvasDrawStringRectWithShadows) {
+  gfx::Size size(50, 50);
+  SkColor check_color = SK_ColorBLUE;
+  SkColor halo_color = SK_ColorWHITE;
+  GetCompositor()->SetScaleAndSize(1.0f, size);
+  scoped_ptr<Layer> layer(CreateDrawStringLayer(
+      gfx::Rect(size), check_color, halo_color,
+      DrawStringLayer::STRING_WITH_SHADOWS));
+  DrawTree(layer.get());
+
+  SkBitmap bitmap;
+  ReadPixels(&bitmap);
+  ASSERT_FALSE(bitmap.empty());
+
+  EXPECT_FALSE(CompareColor(bitmap, size, check_color));
+  EXPECT_FALSE(HasColor(bitmap, size, halo_color));
+}
+
 // 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
   scoped_ptr<Layer> l0(CreateColorLayer(SK_ColorRED,
                                         gfx::Rect(0, 0, 50, 50)));
   scoped_ptr<Layer> l11(CreateColorLayer(SK_ColorGREEN,
@@ skipping 646 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