Remove unused Canvas::DrawStringRectWithShadows().

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 80 matching lines @@
  private:
   SkColor color_;
 };
 
 // Layer delegate for painting text with effects on canvas.
 class DrawStringLayerDelegate : public LayerDelegate {
  public:
   enum DrawFunction {
     STRING_WITH_HALO,
     STRING_FADED,
-    STRING_WITH_SHADOWS
   };
 
   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 {}
 
   // 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 {}
 
  private:
@@ skipping 1371 matching lines @@
 
   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,
-      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_with_shadows.png");
-  // WritePNGFile(bitmap, ref_img, true);
-
-  float percentage_pixels_large_error = 7.4f;  // 185px / (50*50)
-  float percentage_pixels_small_error = 0.0f;
-  float average_error_allowed_in_bad_pixels = 60.f;
-  int large_error_allowed = 246;
-  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)));
-}
 #endif  // defined(OS_WIN)
 
 // 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(
@@ skipping 703 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