[Favicon] Add new fallback icon rendering flow.

components/favicon_base/fallback_icon_style_builder.cc

Index: components/favicon_base/fallback_icon_style_builder.cc
diff --git a/components/favicon_base/fallback_icon_style_builder.cc b/components/favicon_base/fallback_icon_style_builder.cc
new file mode 100644
index 0000000000000000000000000000000000000000..a605c33781c44cd3bf1aa98ee5a5bfbc20f682e0
--- /dev/null
+++ b/components/favicon_base/fallback_icon_style_builder.cc
@@ -0,0 +1,163 @@
+// Copyright 2015 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 "components/favicon_base/fallback_icon_style_builder.h"
+
+#include <string>
+#include <vector>
+
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/string_split.h"
+#include "ui/gfx/color_utils.h"
+
+namespace favicon_base {
+
+namespace {
+
+double kMaxFontSizeRatio = 1.0;
+double kMaxRoundness = 1.0;
+
+// Luminance threshold for background color determine whether to use dark or
+// light text color.
+int kDarkTextLuminanceThreshold = 190;
+
+// Default values.
+SkColor kDefaultBackgroundColor = SkColorSetRGB(0x80, 0x80, 0x80);
+SkColor kDefaultTextColorDark = SK_ColorBLACK;
+SkColor kDefaultTextColorLight = SK_ColorWHITE;
+double kDefaultFontSizeRatio = 0.8;
+double kDefaultRoundness = 0.125;  // 1 / 8.
+
+}  // namespace
+
+FallbackIconStyleBuilder::FallbackIconStyleBuilder()
+    : is_init_(0U) {
+}
+
+FallbackIconStyleBuilder::~FallbackIconStyleBuilder() {
+}
+
+bool FallbackIconStyleBuilder::Reset() {
+  is_init_ = 0U;
+  specs_ = FallbackIconStyle();
+  return false;  // This is to simplify Parse().
+}
+
+bool FallbackIconStyleBuilder::Has(DataMember mask) const {
+  return (is_init_ & mask) != 0;
+}
+
+// Setters, which does not validate |value|.
+void FallbackIconStyleBuilder::SetBackgroundColor(SkColor value) {
+  is_init_ |= BACKGROUND_COLOR;
+  specs_.background_color = value;
+}
+
+void FallbackIconStyleBuilder::SetTextColor(SkColor value) {
+  is_init_ |= TEXT_COLOR;
+  specs_.text_color = value;
+}
+
+void FallbackIconStyleBuilder::SetFontSizeRatio(double value) {
+  is_init_ |= FONT_SIZE_RATIO;
+  specs_.font_size_ratio = value;
+}
+
+void FallbackIconStyleBuilder::SetRoundness(double value) {
+  is_init_ |= ROUNDNESS;
+  specs_.roundness = value;
+}
+
+// static
+bool FallbackIconStyleBuilder::ParseColor(const std::string& str,
+                                          SkColor* color) {
+  size_t len = str.length();
+  if (len != 3 && len != 6 && len != 8)
+    return false;
+  // Translate and validate each digits.
+  int d[8];
+  for (size_t i = 0; i < len; ++i) {

[pkotwicz, 2015/01/21 19:44:15]

Nit: can you use base::HexStringToInt() ?

[huangs, 2015/01/22 01:13:28]

Note that I wish to avoid memory allocation in this routine, and I need to
validate that |str| is valid.

I thought of using HexStringToInt().  There are 3 possible cases:
(1) Depending on length, we use this to extract substrings of |str| and get RGB
through multiple calls. That's kinda bad.
(2) Call HexStringToInt() once to convert str (into uint32), then shift out the
pieces.  But that's kinda silly since the routine packs the digits into a
number, so we have to unpack it again.
(3) Call HexStringToInt() for each character: same problem with substrings, and
lots of overhead.

What would be nice is to have base::BaseCharToDigit::Convert(), but that's not
exposed in the interface.  So I figured screw it, this won't compile to that
much code anyway.

+    char ch = str[i];
+    if (ch >= '0' && ch <= '9')
+      d[i] = ch - '0';
+    else if (ch >= 'A' && ch <= 'F')
+      d[i] = (ch - 'A') + 10;
+    else if (ch >= 'a' && ch <= 'f')
+      d[i] = (ch - 'a') + 10;
+    else
+      return false;
+  }
+  if (len == 3) {  // RGB.
+    *color = SkColorSetRGB(d[0] * 0x11, d[1] * 0x11, d[2] * 0x11);
+  } else if (len == 6) {  // RRGGBB.
+    *color = SkColorSetRGB(
+        (d[0] << 4) | d[1], (d[2] << 4) | d[3], (d[4] << 4) | d[5]);
+  } else {  // RRGGBBAA.
+    DCHECK(len == 8);
+    *color = SkColorSetARGB((d[6] << 4) | d[7], (d[0] << 4) | d[1],
+                            (d[2] << 4) | d[3], (d[4] << 4) | d[5]);
+  }
+  return true;
+}
+
+bool FallbackIconStyleBuilder::Parse(const std::string& specs_str) {

[pkotwicz, 2015/01/21 19:44:15]

Can this method return a FallbackIconStyle? (And change the default
FallbackIconStyle() constructor to create a FallbackIconStyle with the correct
defaults)

[huangs, 2015/01/22 01:13:28]

I consider Parse() to be a sibling of SetBackgroundColor() etc, so it should
allow fields to be unspecified if necessary -- although a failed parse will kill
everything.

A use case is to allow the explicit flow to allow background to be unspecified,
so we can test the flow to grab favicon and extract dominant color.  Though this
would require FallbackIconSource to grab FaviconService (and then implicit flow
requires FaviconSource to grab FallbackIconService).  I guess that's an argument
for having one service...  Will revisit this later.

[pkotwicz, 2015/01/22 16:14:20]

Ok, I am fine with allowing empty arguments

[huangs, 2015/01/22 22:51:39]

Done, how we always have ",".

+  Reset();
+  std::vector<std::string> tokens;
+  base::SplitStringDontTrim(specs_str, ',', &tokens);
+  if (tokens.size() > 4)  // Too many fields.

[pkotwicz, 2015/01/21 19:44:15]

I think that it makes more sense to make all of the fields mandatory.

[huangs, 2015/01/22 01:13:28]

As mentioned above, Parse() can still leave blanks field for more complex
defaults (dominant color).

[pkotwicz, 2015/01/22 16:14:20]

I think we can make all of the fields mandatory and allow blank values. I think
that this is simplest.

My understanding is that the goals are:
- Have a temporary way for JS in the NTP to display fallback icons. Eventually,
the NTP will switch to using implicit icons.
- Have a temporary way for UX folks to try out different parameters for fallback
icons.

In light of these goals, I think that code compexity should dictate the
parameter format, not user friendliness.

[huangs, 2015/01/22 22:51:39]

Done.

+    return Reset();  // Returns false.
+
+  SkColor temp_color;
+  double temp_double;
+  if (tokens.size() > 0 && !tokens[0].empty()) {
+    if (!ParseColor(tokens[0], &temp_color))
+      return Reset();

[pkotwicz, 2015/01/21 19:44:16]

How about leaving the background color as the default if parsing the color
failed?

[huangs, 2015/01/22 01:13:28]

Note we impose strict limit for FontSizeRatio and Roundness (cannot be
negative), it's better to make everything strict, and only assign defaults when
intended via AssignDefaults() and Build().

+    SetBackgroundColor(temp_color);
+  }
+  if (tokens.size() > 1 && !tokens[1].empty()) {
+    if (!ParseColor(tokens[1], &temp_color))
+      return Reset();
+    SetTextColor(temp_color);
+  }
+  if (tokens.size() > 2 && !tokens[2].empty()) {
+    if (!base::StringToDouble(tokens[2], &temp_double) ||
+            temp_double < 0.0 || temp_double > kMaxFontSizeRatio) {
+      return Reset();
+    }
+    SetFontSizeRatio(temp_double);
+  }
+  if (tokens.size() > 3 && !tokens[3].empty()) {
+    if (!base::StringToDouble(tokens[3], &temp_double) ||
+            temp_double < 0.0 || temp_double > kMaxRoundness) {
+      return Reset();
+    }
+    SetRoundness(temp_double);
+  }
+  return true;
+}
+
+void FallbackIconStyleBuilder::AssignDefaults() {
+  if (!Has(BACKGROUND_COLOR))
+    SetBackgroundColor(kDefaultBackgroundColor);
+
+  // Uses dark/light text for background with high/low luminance.
+  if (!Has(TEXT_COLOR)) {
+    int luminance = color_utils::GetLuminanceForColor(specs_.background_color);
+    SetTextColor(luminance >= kDarkTextLuminanceThreshold ?
+        kDefaultTextColorDark : kDefaultTextColorLight);
+  }
+
+  if (!Has(FONT_SIZE_RATIO))
+    SetFontSizeRatio(kDefaultFontSizeRatio);
+
+  if (!Has(ROUNDNESS))
+    SetRoundness(kDefaultRoundness);
+}
+
+const FallbackIconStyle& FallbackIconStyleBuilder::Build() {
+  AssignDefaults();
+  return specs_;
+}
+
+}  // namespace favicon_base