RenderText: Allow strike-through line thickness to be customized.

chrome/browser/android/vr_shell/textures/url_bar_texture_unittest.cc

 // Copyright 2017 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 "chrome/browser/android/vr_shell/textures/url_bar_texture.h"
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 18 matching lines @@
 static const SkColor kEmphasizedColor = 0xFF000000;
 static const SkColor kDeemphasizedColor = 0xFF5A5A5A;
 static const SkColor kSecureColor = gfx::kGoogleGreen700;
 static const SkColor kWarningColor = gfx::kGoogleRed700;
 
 static const SkColor kIncognitoDeemphasizedColor = 0xFF878787;
 static const SkColor kIncognitoEmphasizedColor = 0xFFEDEDED;
 static const SkColor kIncognitoSecureColor = 0xFFEDEDED;
 static const SkColor kIncognitoWarningColor = 0xFFEDEDED;
 
-static constexpr int kUrlWidth = 400;
-static constexpr int kUrlHeight = 30;
+static constexpr int kUrlWidthPixels = 1024;
 
 class TestUrlBarTexture : public UrlBarTexture {
  public:
   TestUrlBarTexture();
   ~TestUrlBarTexture() override {}
 
   void DrawURL(const GURL& gurl) {
     unsupported_mode_ = UiUnsupportedMode::kCount;
-    ToolbarState state(gurl, SecurityLevel::HTTP_SHOW_WARNING,
+    ToolbarState state(gurl, SecurityLevel::DANGEROUS,
                        &toolbar::kHttpsInvalidIcon,
                        base::UTF8ToUTF16("Not secure"), true);
     ASSERT_TRUE(state.should_display_url);
     SetToolbarState(state);
+    gfx::Size texture_size = GetPreferredTextureSize(kUrlWidthPixels);
     sk_sp<SkSurface> surface = SkSurface::MakeRasterN32Premul(
-        texture_size_.width(), texture_size_.height());
-    DrawAndLayout(surface->getCanvas(), texture_size_);
+        texture_size.width(), texture_size.height());
+    DrawAndLayout(surface->getCanvas(), texture_size);
   }
 
   static void TestUrlStyling(const base::string16& formatted_url,
                              const url::Parsed& parsed,
                              security_state::SecurityLevel security_level,
                              vr_shell::RenderTextWrapper* render_text,
                              const ColorScheme& color_scheme) {
     ApplyUrlStyling(formatted_url, parsed, security_level, render_text,
                     color_scheme);
   }
 
   void SetForceFontFallbackFailure(bool force) {
     SetForceFontFallbackFailureForTesting(force);
   }
 
   size_t GetNumberOfFontFallbacksForURL(const GURL& gurl) {
     url::Parsed parsed;
     const base::string16 text = url_formatter::FormatUrl(
         gurl, url_formatter::kFormatUrlOmitAll, net::UnescapeRule::NORMAL,
         &parsed, nullptr, nullptr);
 
+    gfx::Size texture_size = GetPreferredTextureSize(kUrlWidthPixels);
     gfx::FontList font_list;
-    if (!GetFontList(kUrlHeight, text, &font_list))
+    if (!GetFontList(texture_size.height(), text, &font_list))
       return 0;
 
     return font_list.GetFonts().size();
   }
 
   // Reports the last unsupported mode that was encountered. Returns kCount if
   // no unsupported mode was encountered.
   UiUnsupportedMode unsupported_mode() const { return unsupported_mode_; }
 
   gfx::RenderText* url_render_text() { return url_render_text_.get(); }
   const base::string16& url_text() { return url_text_; }
 
  private:
   void OnUnsupportedFeature(UiUnsupportedMode mode) {
     unsupported_mode_ = mode;
   }
 
-  gfx::Size texture_size_;
-  gfx::Rect bounds_;
   UiUnsupportedMode unsupported_mode_ = UiUnsupportedMode::kCount;
 };
 
 TestUrlBarTexture::TestUrlBarTexture()
     : UrlBarTexture(false,
                     base::Bind(&TestUrlBarTexture::OnUnsupportedFeature,
-                               base::Unretained(this))),
-      texture_size_(kUrlWidth, kUrlHeight),
-      bounds_(kUrlWidth, kUrlHeight) {
+                               base::Unretained(this))) {
   gfx::FontList::SetDefaultFontDescription("Arial, Times New Roman, 15px");
 }
 
 class MockRenderText : public RenderTextWrapper {
  public:
   MockRenderText() : RenderTextWrapper(nullptr) {}
   ~MockRenderText() override {}
 
   MOCK_METHOD1(SetColor, void(SkColor value));
   MOCK_METHOD2(ApplyColor, void(SkColor value, const gfx::Range& range));
   MOCK_METHOD2(SetStyle, void(gfx::TextStyle style, bool value));
   MOCK_METHOD3(ApplyStyle,
                void(gfx::TextStyle style, bool value, const gfx::Range& range));
+  MOCK_METHOD1(SetStrikeThicknessFactor, void(SkScalar));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockRenderText);
 };
 
 class UrlEmphasisTest : public testing::Test {
  protected:
   void Verify(const std::string& url_string,
               SecurityLevel level,
               const std::string& expected_string) {
@@ skipping 50 matching lines @@
   EXPECT_CALL(mock_, SetColor(kIncognitoDeemphasizedColor));
   EXPECT_CALL(mock_, ApplyColor(kIncognitoEmphasizedColor, gfx::Range(0, 8)));
   Verify("http://host.com/page", SecurityLevel::HTTP_SHOW_WARNING,
          "host.com/page");
 }
 
 TEST_F(UrlEmphasisTest, DangerousHttpsHost) {
   EXPECT_CALL(mock_, SetColor(kDeemphasizedColor));
   EXPECT_CALL(mock_, ApplyColor(kEmphasizedColor, gfx::Range(8, 16)));
   EXPECT_CALL(mock_, ApplyColor(kWarningColor, gfx::Range(0, 5)));
+  EXPECT_CALL(mock_, SetStrikeThicknessFactor(testing::_));
   EXPECT_CALL(mock_,
               ApplyStyle(gfx::TextStyle::STRIKE, true, gfx::Range(0, 5)));
   EXPECT_CALL(mock_, SetColor(kIncognitoDeemphasizedColor));
   EXPECT_CALL(mock_, ApplyColor(kIncognitoEmphasizedColor, gfx::Range(8, 16)));
   EXPECT_CALL(mock_, ApplyColor(kIncognitoWarningColor, gfx::Range(0, 5)));
+  EXPECT_CALL(mock_, SetStrikeThicknessFactor(testing::_));
   EXPECT_CALL(mock_,
               ApplyStyle(gfx::TextStyle::STRIKE, true, gfx::Range(0, 5)));
   Verify("https://host.com/page", SecurityLevel::DANGEROUS,
          "https://host.com/page");
 }
 
 TEST_F(UrlEmphasisTest, Data) {
   EXPECT_CALL(mock_, SetColor(kDeemphasizedColor));
   EXPECT_CALL(mock_, ApplyColor(kEmphasizedColor, gfx::Range(0, 4)));
   EXPECT_CALL(mock_, SetColor(kIncognitoDeemphasizedColor));
@@ skipping 80 matching lines @@
   EXPECT_EQ(UiUnsupportedMode::kCount, texture.unsupported_mode());
 }
 
 TEST(UrlBarTexture, EmptyURL) {
   TestUrlBarTexture texture;
   texture.DrawURL(GURL());
   EXPECT_EQ(UiUnsupportedMode::kCount, texture.unsupported_mode());
 }
 
 }  // namespace vr_shell