Remove 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>
@@ skipping 74 matching lines @@
   }
 
   void OnDelegatedFrameDamage(const gfx::Rect& damage_rect_in_dip) override {}
 
   void OnDeviceScaleFactorChanged(float device_scale_factor) override {}
 
  private:
   SkColor color_;
 };
 
-// Layer delegate for painting text with effects on canvas.
-class DrawStringLayerDelegate : public LayerDelegate {
+// Layer delegate for painting text with fade effect on canvas.
+class DrawFadedStringLayerDelegateDelegate : public LayerDelegate {

[msw, 2017/01/26 00:52:10]

nit: DelegateDelegate?

[Evan Stade, 2017/03/22 22:59:56]

Done.

  public:
-  enum DrawFunction {
-    STRING_WITH_HALO,
-    STRING_FADED,
-  };
+  DrawFadedStringLayerDelegateDelegate(SkColor back_color,
+                                       const gfx::Size& layer_size)
+      : background_color_(back_color), layer_size_(layer_size) {}
 
-  DrawStringLayerDelegate(
-      SkColor back_color, SkColor halo_color,
-      DrawFunction func, const gfx::Size& layer_size)
-      : background_color_(back_color),
-        halo_color_(halo_color),
-        func_(func),
-        layer_size_(layer_size) {
-  }
-
-  ~DrawStringLayerDelegate() override {}
+  ~DrawFadedStringLayerDelegateDelegate() override {}
 
   // 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;
-      default:
-        NOTREACHED();
-    }
+    recorder.canvas()->DrawFadedString(text, font_list_, SK_ColorRED, bounds,
+                                       0);
   }
 
   void OnDelegatedFrameDamage(const gfx::Rect& damage_rect_in_dip) override {}
 
   void OnDeviceScaleFactorChanged(float device_scale_factor) override {}
 
  private:
   const SkColor background_color_;
-  const SkColor halo_color_;
-  const DrawFunction func_;
   const gfx::FontList font_list_;
   const gfx::Size layer_size_;
 
-  DISALLOW_COPY_AND_ASSIGN(DrawStringLayerDelegate);
+  DISALLOW_COPY_AND_ASSIGN(DrawFadedStringLayerDelegateDelegate);
 };
 
 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.";
     }
@@ skipping 35 matching lines @@
     layer->SetBounds(bounds);
     return layer;
   }
 
   Layer* CreateNoTextureLayer(const gfx::Rect& bounds) {
     Layer* layer = CreateLayer(LAYER_NOT_DRAWN);
     layer->SetBounds(bounds);
     return layer;
   }
 
-  std::unique_ptr<Layer> CreateDrawStringLayer(
-      const gfx::Rect& bounds, DrawStringLayerDelegate* delegate) {
+  std::unique_ptr<Layer> CreateDrawFadedStringLayerDelegate(
+      const gfx::Rect& bounds,
+      DrawFadedStringLayerDelegateDelegate* delegate) {
     std::unique_ptr<Layer> layer(new Layer(LAYER_TEXTURED));
     layer->SetBounds(bounds);
     layer->set_delegate(delegate);
     return layer;
   }
 
   void DrawTree(Layer* root) {
     GetCompositor()->SetRootLayer(root);
     GetCompositor()->ScheduleDraw();
     WaitForSwap();
@@ skipping 1230 matching lines @@
   ReadPixels(&bitmap);
   ASSERT_FALSE(bitmap.empty());
   EXPECT_TRUE(MatchesPNGFile(bitmap, ref_img2, cc::ExactPixelComparator(true)));
 }
 
 // It is really hard to write pixel test on text rendering,
 // due to different font appearance.
 // So we choose to check result only on Windows.
 // See https://codereview.chromium.org/1634103003/#msg41
 #if defined(OS_WIN)
-TEST_F(LayerWithRealCompositorTest, CanvasDrawStringRectWithHalo) {
+TEST_F(LayerWithRealCompositorTest, CanvasDrawFadedString) {
   gfx::Size size(50, 50);
   GetCompositor()->SetScaleAndSize(1.0f, size);
-  DrawStringLayerDelegate delegate(SK_ColorBLUE, SK_ColorWHITE,
-                                   DrawStringLayerDelegate::STRING_WITH_HALO,
-                                   size);
+  DrawFadedStringLayerDelegateDelegate delegate(SK_ColorBLUE, SK_ColorWHITE,
+                                                size);
   std::unique_ptr<Layer> layer(
-      CreateDrawStringLayer(gfx::Rect(size), &delegate));
+      CreateDrawFadedStringLayerDelegate(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);
-
-  float percentage_pixels_large_error = 1.0f;
-  float percentage_pixels_small_error = 0.0f;
-  float average_error_allowed_in_bad_pixels = 1.f;
-  int large_error_allowed = 1;
-  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,
-                                   size);
-  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);
 
   float percentage_pixels_large_error = 8.0f;  // 200px / (50*50)
   float percentage_pixels_small_error = 0.0f;
   float average_error_allowed_in_bad_pixels = 80.f;
@@ skipping 771 matching lines @@
   layer.set_name("foo");
   std::unique_ptr<base::trace_event::ConvertableToTraceFormat> debug_info =
       layer.TakeDebugInfo(nullptr);
   std::string trace_format("bar,");
   debug_info->AppendAsTraceFormat(&trace_format);
   std::string expected("bar,{\"layer_name\":\"foo\"}");
   EXPECT_EQ(expected, trace_format);
 }
 
 }  // namespace ui