Remove gfx::DIAGONAL_STRIKE and supporting code.

ui/gfx/render_text_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/gfx/render_text.h"
 
 #include <limits.h>
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 147 matching lines @@
 const wchar_t kRtl[] =       L"\x5d0\x5d1\x5d2";
 const wchar_t kLtrRtl[] =    L"a" L"\x5d0\x5d1";
 const wchar_t kLtrRtlLtr[] = L"a" L"\x5d1" L"b";
 const wchar_t kRtlLtr[] =    L"\x5d0\x5d1" L"a";
 const wchar_t kRtlLtrRtl[] = L"\x5d0" L"a" L"\x5d1";
 
 // Bitmasks based on gfx::TextStyle.
 enum {
   ITALIC_MASK = 1 << ITALIC,
   STRIKE_MASK = 1 << STRIKE,
-  DIAGONAL_STRIKE_MASK = 1 << DIAGONAL_STRIKE,
   UNDERLINE_MASK = 1 << UNDERLINE,
 };
 
 // Checks whether |range| contains |index|. This is not the same as calling
 // range.Contains(Range(index)), which returns true if |index| == |range.end()|.
 bool IndexInRange(const Range& range, size_t index) {
   return index >= range.start() && index < range.end();
 }
 
 base::string16 GetSelectedText(RenderText* render_text) {
@@ skipping 65 matching lines @@
   int font_style = Font::NORMAL;
   if (style_mask & ITALIC_MASK)
     font_style |= Font::ITALIC;
   if (style_mask & UNDERLINE_MASK)
     font_style |= Font::UNDERLINE;
 
   const Font font_with_style = font.Derive(0, font_style, weight);
   DecoratedText::RangedAttribute attributes(Range(index, index + 1),
                                             font_with_style);
   attributes.strike = style_mask & STRIKE_MASK;
-  attributes.diagonal_strike = style_mask & DIAGONAL_STRIKE_MASK;
   return attributes;
 }
 
 // Verifies the given DecoratedText instances are equal by comparing the
 // respective strings and attributes for each index. Note, corresponding
 // ranged attributes from |expected| and |actual| can't be compared since the
 // partition of |actual| into RangedAttributes will depend on the text runs
 // generated.
 void VerifyDecoratedWordsAreEqual(const DecoratedText& expected,
                                   const DecoratedText& actual) {
   ASSERT_EQ(expected.text, actual.text);
 
   // Compare attributes for each index.
   for (size_t i = 0; i < expected.text.length(); i++) {
     SCOPED_TRACE(base::StringPrintf("Comparing index[%" PRIuS "]", i));
     auto find_attribute_func = [i](const DecoratedText::RangedAttribute& attr) {
       return IndexInRange(attr.range, i);
     };
     const auto expected_attr =
         std::find_if(expected.attributes.begin(), expected.attributes.end(),
                      find_attribute_func);
     const auto actual_attr =
         std::find_if(actual.attributes.begin(), actual.attributes.end(),
                      find_attribute_func);
     ASSERT_NE(expected.attributes.end(), expected_attr);
     ASSERT_NE(actual.attributes.end(), actual_attr);
 
     EXPECT_EQ(expected_attr->strike, actual_attr->strike);
-    EXPECT_EQ(expected_attr->diagonal_strike, actual_attr->diagonal_strike);
     EXPECT_EQ(expected_attr->font.GetFontName(),
               actual_attr->font.GetFontName());
     EXPECT_EQ(expected_attr->font.GetFontSize(),
               actual_attr->font.GetFontSize());
     EXPECT_EQ(expected_attr->font.GetWeight(), actual_attr->font.GetWeight());
     EXPECT_EQ(expected_attr->font.GetStyle(), actual_attr->font.GetStyle());
   }
 }
 
 // Helper method to return an obscured string of the given |length|, with the
@@ skipping 16 matching lines @@
 class TestSkiaTextRenderer : public internal::SkiaTextRenderer {
  public:
   struct TextLog {
     TextLog() : glyph_count(0u), color(SK_ColorTRANSPARENT) {}
     PointF origin;
     size_t glyph_count;
     SkColor color;
   };
 
   struct DecorationLog {
-    DecorationLog(int x, int y, int width, bool underline, bool strike,
-                  bool diagonal_strike)
-        : x(x), y(y), width(width), underline(underline), strike(strike),
-          diagonal_strike(diagonal_strike) {}
+    DecorationLog(int x, int y, int width, bool underline, bool strike)
+        : x(x), y(y), width(width), underline(underline), strike(strike) {}
     int x;
     int y;
     int width;
     bool underline;
     bool strike;
-    bool diagonal_strike;
   };
 
   explicit TestSkiaTextRenderer(Canvas* canvas)
       : internal::SkiaTextRenderer(canvas) {}
   ~TestSkiaTextRenderer() override {}
 
   void GetTextLogAndReset(std::vector<TextLog>* text_log) {
     text_log_.swap(*text_log);
     text_log_.clear();
   }
@@ skipping 17 matching lines @@
         log_entry.origin.SetToMin(
             PointF(SkScalarToFloat(pos[i].x()), SkScalarToFloat(pos[i].y())));
       }
     }
     log_entry.color =
         test::RenderTextTestApi::GetRendererPaint(this).getColor();
     text_log_.push_back(log_entry);
     internal::SkiaTextRenderer::DrawPosText(pos, glyphs, glyph_count);
   }
 
-  void DrawDecorations(int x, int y, int width, bool underline, bool strike,
-                       bool diagonal_strike) override {
-    decoration_log_.push_back(
-        DecorationLog(x, y, width, underline, strike, diagonal_strike));
-    internal::SkiaTextRenderer::DrawDecorations(
-        x, y, width, underline, strike, diagonal_strike);
+  void DrawDecorations(int x,
+                       int y,
+                       int width,
+                       bool underline,
+                       bool strike) override {
+    decoration_log_.push_back(DecorationLog(x, y, width, underline, strike));
+    internal::SkiaTextRenderer::DrawDecorations(x, y, width, underline, strike);
   }
 
   std::vector<TextLog> text_log_;
   std::vector<DecorationLog> decoration_log_;
 
   DISALLOW_COPY_AND_ASSIGN(TestSkiaTextRenderer);
 };
 
 // Given a buffer to test against, this can be used to test various areas of the
 // rectangular buffer against a specific color value.
@@ skipping 666 matching lines @@
   base::string16 input_text;
   // Aim for 3 lines of text.
   for (int i = 0; i < 20; ++i)
     input_text.append(ASCIIToUTF16("hello world "));
   render_text->SetText(input_text);
   // Apply a style that tweaks the layout to make sure elision is calculated
   // with these styles. This can expose a behavior in layout where text is
   // slightly different width. This must be done after |SetText()|.
   render_text->ApplyWeight(Font::Weight::BOLD, Range(1, 20));
   render_text->ApplyStyle(ITALIC, true, Range(1, 20));
-  render_text->ApplyStyle(DIAGONAL_STRIKE, true, Range(1, 20));
   render_text->SetMultiline(true);
   render_text->SetElideBehavior(ELIDE_TAIL);
   render_text->SetMaxLines(3);
   const Size size = render_text->GetStringSize();
   // Fit in 3 lines. (If we knew the width of a word, we could
   // anticipate word wrap better.)
   render_text->SetDisplayRect(Rect((size.width() + 96) / 3, 0));
   // Trigger rendering.
   render_text->GetStringSize();
   EXPECT_EQ(input_text, render_text->GetDisplayText());
@@ skipping 2994 matching lines @@
   const base::string16 ltr = ASCIIToUTF16("  ab  c ");
   const int kWordOneStartIndex = 2;
   const int kWordTwoStartIndex = 6;
 
   RenderText* render_text = GetRenderText();
   render_text->SetDisplayRect(Rect(100, 30));
   render_text->SetText(ltr);
   render_text->ApplyWeight(Font::Weight::SEMIBOLD, Range(0, 3));
   render_text->ApplyStyle(UNDERLINE, true, Range(1, 5));
   render_text->ApplyStyle(ITALIC, true, Range(3, 8));
-  render_text->ApplyStyle(DIAGONAL_STRIKE, true, Range(5, 7));
   render_text->ApplyStyle(STRIKE, true, Range(1, 7));
   const int cursor_y = GetCursorYForTesting();
 
   const std::vector<RenderText::FontSpan> font_spans =
       render_text->GetFontSpansForTesting();
 
   // Create expected decorated text instances.
   DecoratedText expected_word_1;
   expected_word_1.text = ASCIIToUTF16("ab");
   // Attributes for the characters 'a' and 'b' at logical indices 2 and 3
   // respectively.
   expected_word_1.attributes.push_back(CreateRangedAttribute(
       font_spans, 0, kWordOneStartIndex, Font::Weight::SEMIBOLD,
       UNDERLINE_MASK | STRIKE_MASK));
   expected_word_1.attributes.push_back(CreateRangedAttribute(
       font_spans, 1, kWordOneStartIndex + 1, Font::Weight::NORMAL,
       UNDERLINE_MASK | ITALIC_MASK | STRIKE_MASK));
   const Rect left_glyph_word_1 = render_text->GetCursorBounds(
       SelectionModel(kWordOneStartIndex, CURSOR_FORWARD), false);
 
   DecoratedText expected_word_2;
   expected_word_2.text = ASCIIToUTF16("c");
   // Attributes for character 'c' at logical index |kWordTwoStartIndex|.
-  expected_word_2.attributes.push_back(CreateRangedAttribute(
-      font_spans, 0, kWordTwoStartIndex, Font::Weight::NORMAL,
-      ITALIC_MASK | DIAGONAL_STRIKE_MASK | STRIKE_MASK));
+  expected_word_2.attributes.push_back(
+      CreateRangedAttribute(font_spans, 0, kWordTwoStartIndex,
+                            Font::Weight::NORMAL, ITALIC_MASK | STRIKE_MASK));
   const Rect left_glyph_word_2 = render_text->GetCursorBounds(
       SelectionModel(kWordTwoStartIndex, CURSOR_FORWARD), false);
 
   DecoratedText decorated_word;
   Point baseline_point;
 
   {
     SCOPED_TRACE(base::StringPrintf("Query to the left of text bounds"));
     EXPECT_TRUE(render_text->GetDecoratedWordAtPoint(
         Point(-5, cursor_y), &decorated_word, &baseline_point));
@@ skipping 38 matching lines @@
       L"\x0634");
   const int kWordOneStartIndex = 1;
   const int kWordTwoStartIndex = 5;
 
   RenderText* render_text = GetRenderText();
   render_text->SetDisplayRect(Rect(100, 30));
   render_text->SetText(rtl);
   render_text->ApplyWeight(Font::Weight::SEMIBOLD, Range(2, 3));
   render_text->ApplyStyle(UNDERLINE, true, Range(3, 6));
   render_text->ApplyStyle(ITALIC, true, Range(0, 3));
-  render_text->ApplyStyle(DIAGONAL_STRIKE, true, Range(0, 2));
   render_text->ApplyStyle(STRIKE, true, Range(2, 5));
   const int cursor_y = GetCursorYForTesting();
 
   const std::vector<RenderText::FontSpan> font_spans =
       render_text->GetFontSpansForTesting();
 
   // Create expected decorated text instance.
   DecoratedText expected_word_1;
   expected_word_1.text = WideToUTF16(L"\x0634\x0632");
   // Attributes for characters at logical indices 1 and 2.
   expected_word_1.attributes.push_back(CreateRangedAttribute(
-      font_spans, 0, kWordOneStartIndex, Font::Weight::NORMAL,
-      ITALIC_MASK | DIAGONAL_STRIKE_MASK));
+      font_spans, 0, kWordOneStartIndex, Font::Weight::NORMAL, ITALIC_MASK));
   expected_word_1.attributes.push_back(
       CreateRangedAttribute(font_spans, 1, kWordOneStartIndex + 1,
                             Font::Weight::SEMIBOLD, ITALIC_MASK | STRIKE_MASK));
   // The leftmost glyph is the one at logical index 2.
   const Rect left_glyph_word_1 = render_text->GetCursorBounds(
       SelectionModel(kWordOneStartIndex + 1, CURSOR_FORWARD), false);
 
   DecoratedText expected_word_2;
   expected_word_2.text = WideToUTF16(L"\x0634");
   // Attributes for character at logical index |kWordTwoStartIndex|.
@@ skipping 366 matching lines @@
                         ::testing::Values(RENDER_TEXT_HARFBUZZ),
                         PrintRenderTextBackend());
 #endif
 
 INSTANTIATE_TEST_CASE_P(,
                         RenderTextHarfBuzzTest,
                         ::testing::Values(RENDER_TEXT_HARFBUZZ),
                         PrintRenderTextBackend());
 
 }  // namespace gfx