Allow various font weights in gfx.

ui/gfx/font_render_params_linux.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/font_render_params.h"
 
 #include <fontconfig/fontconfig.h>
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 10 matching lines @@
 #include "base/synchronization/lock.h"
 #include "build/build_config.h"
 #include "ui/gfx/font.h"
 #include "ui/gfx/linux_font_delegate.h"
 #include "ui/gfx/switches.h"
 
 namespace gfx {
 
 namespace {
 
+int FontWeightToFCWeight(Font::Weight weight) {
+  const int weight_number = static_cast<int>(weight);
+  if (weight_number <= (static_cast<int>(Font::Weight::THIN) +
+                        static_cast<int>(Font::Weight::EXTRA_LIGHT)) /
+                           2)
+    return FC_WEIGHT_THIN;
+  else if (weight_number <= (static_cast<int>(Font::Weight::EXTRA_LIGHT) +
+                             static_cast<int>(Font::Weight::LIGHT)) /
+                                2)
+    return FC_WEIGHT_ULTRALIGHT;
+  else if (weight_number <= (static_cast<int>(Font::Weight::LIGHT) +
+                             static_cast<int>(Font::Weight::NORMAL)) /
+                                2)
+    return FC_WEIGHT_LIGHT;
+  else if (weight_number <= (static_cast<int>(Font::Weight::NORMAL) +
+                             static_cast<int>(Font::Weight::MEDIUM)) /
+                                2)
+    return FC_WEIGHT_NORMAL;
+  else if (weight_number <= (static_cast<int>(Font::Weight::MEDIUM) +
+                             static_cast<int>(Font::Weight::SEMIBOLD)) /
+                                2)
+    return FC_WEIGHT_MEDIUM;
+  else if (weight_number <= (static_cast<int>(Font::Weight::SEMIBOLD) +
+                             static_cast<int>(Font::Weight::BOLD)) /
+                                2)
+    return FC_WEIGHT_DEMIBOLD;
+  else if (weight_number <= (static_cast<int>(Font::Weight::BOLD) +
+                             static_cast<int>(Font::Weight::EXTRA_BOLD)) /
+                                2)
+    return FC_WEIGHT_BOLD;
+  else if (weight_number <= (static_cast<int>(Font::Weight::EXTRA_BOLD) +
+                             static_cast<int>(Font::Weight::BLACK)) /
+                                2)
+    return FC_WEIGHT_ULTRABOLD;
+  else
+    return FC_WEIGHT_BLACK;
+}
+
 // A device scale factor used to determine if subpixel positioning
 // should be used.
 float device_scale_factor_ = 1.0f;
 
 // Number of recent GetFontRenderParams() results to cache.
 const size_t kCacheSize = 256;
 
 // Cached result from a call to GetFontRenderParams().
 struct QueryResult {
   QueryResult(const FontRenderParams& params, const std::string& family)
@@ skipping 64 matching lines @@
     FcPatternAddString(query_pattern.get(),
         FC_FAMILY, reinterpret_cast<const FcChar8*>(it->c_str()));
   }
   if (query.pixel_size > 0)
     FcPatternAddDouble(query_pattern.get(), FC_PIXEL_SIZE, query.pixel_size);
   if (query.point_size > 0)
     FcPatternAddInteger(query_pattern.get(), FC_SIZE, query.point_size);
   if (query.style >= 0) {
     FcPatternAddInteger(query_pattern.get(), FC_SLANT,
         (query.style & Font::ITALIC) ? FC_SLANT_ITALIC : FC_SLANT_ROMAN);
+  }
+  if (query.weight != Font::Weight::INVALID) {
     FcPatternAddInteger(query_pattern.get(), FC_WEIGHT,
-        (query.style & Font::BOLD) ? FC_WEIGHT_BOLD : FC_WEIGHT_NORMAL);
+                        FontWeightToFCWeight(query.weight));
   }
 
   FcConfigSubstitute(NULL, query_pattern.get(), FcMatchPattern);
   FcDefaultSubstitute(query_pattern.get());
 
   ScopedFcPattern result_pattern;
   if (query.is_empty()) {
     // If the query was empty, call FcConfigSubstituteWithPat() to get a
     // non-family- or size-specific configuration so it can be used as the
     // default.
@@ skipping 57 matching lines @@
       params_out->subpixel_rendering = ConvertFontconfigRgba(fc_rgba);
   }
 
   return true;
 }
 
 // Serialize |query| into a string and hash it to a value suitable for use as a
 // cache key.
 uint32_t HashFontRenderParamsQuery(const FontRenderParamsQuery& query) {
   return base::Hash(base::StringPrintf(
-      "%d|%d|%d|%s|%f", query.pixel_size, query.point_size, query.style,
+      "%d|%d|%d|%d|%s|%f", query.pixel_size, query.point_size, query.style,
+      static_cast<int>(query.weight),
       base::JoinString(query.families, ",").c_str(),
       query.device_scale_factor));
 }
 
 }  // namespace
 
 FontRenderParams GetFontRenderParams(const FontRenderParamsQuery& query,
                                      std::string* family_out) {
   FontRenderParamsQuery actual_query(query);
   if (actual_query.device_scale_factor == 0)
@@ skipping 63 matching lines @@
 
 float GetFontRenderParamsDeviceScaleFactor() {
   return device_scale_factor_;
 }
 
 void SetFontRenderParamsDeviceScaleFactor(float device_scale_factor) {
   device_scale_factor_ = device_scale_factor;
 }
 
 }  // namespace gfx