Use the WebKit default fonts when specifying generic font families.

webkit/plugins/ppapi/webkit_forwarding_impl.cc

 // Copyright (c) 2011 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 "webkit/plugins/ppapi/webkit_forwarding_impl.h"
 
 #include "base/scoped_ptr.h"
+#include "base/string_util.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/utf_string_conversions.h"
 #include "ppapi/c/dev/ppb_font_dev.h"
 #include "ppapi/c/pp_point.h"
 #include "ppapi/c/pp_rect.h"
+#include "ppapi/shared_impl/ppapi_preferences.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebCanvas.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFont.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFontDescription.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebRect.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFloatPoint.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFloatRect.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebTextRun.h"
 #include "webkit/glue/webkit_glue.h"
 
@@ skipping 13 matching lines @@
 
 // The PP_* version lacks "None", so is just one value shifted from the
 // WebFontDescription version. These values are checked in
 // PPFontDescToWebFontDesc to make sure the conversion is correct. This is a
 // macro so it can also be used in the COMPILE_ASSERTS.
 #define PP_FONTFAMILY_TO_WEB_FONTFAMILY(f) \
   static_cast<WebFontDescription::GenericFamily>(f + 1)
 
 // Assumes the given PP_FontDescription has been validated.
 WebFontDescription PPFontDescToWebFontDesc(const PP_FontDescription_Dev& font,
-                                           const std::string& face) {
+                                           const std::string& face,
+                                           const ::ppapi::Preferences& prefs) {
   // Verify that the enums match so we can just static cast.
   COMPILE_ASSERT(static_cast<int>(WebFontDescription::Weight100) ==
                  static_cast<int>(PP_FONTWEIGHT_100),
                  FontWeight100);
   COMPILE_ASSERT(static_cast<int>(WebFontDescription::Weight900) ==
                  static_cast<int>(PP_FONTWEIGHT_900),
                  FontWeight900);
   COMPILE_ASSERT(WebFontDescription::GenericFamilyStandard ==
                  PP_FONTFAMILY_TO_WEB_FONTFAMILY(PP_FONTFAMILY_DEFAULT),
                  StandardFamily);
   COMPILE_ASSERT(WebFontDescription::GenericFamilySerif ==
                  PP_FONTFAMILY_TO_WEB_FONTFAMILY(PP_FONTFAMILY_SERIF),
                  SerifFamily);
   COMPILE_ASSERT(WebFontDescription::GenericFamilySansSerif ==
                  PP_FONTFAMILY_TO_WEB_FONTFAMILY(PP_FONTFAMILY_SANSSERIF),
                  SansSerifFamily);
   COMPILE_ASSERT(WebFontDescription::GenericFamilyMonospace ==
                  PP_FONTFAMILY_TO_WEB_FONTFAMILY(PP_FONTFAMILY_MONOSPACE),
                  MonospaceFamily);
 
   WebFontDescription result;
-  result.family = UTF8ToUTF16(face);
+  string16 resolved_family;
+  if (face.empty()) {
+    // Resolve the generic family.
+    switch (font.family) {
+      case PP_FONTFAMILY_SERIF:
+        resolved_family = prefs.serif_font_family;
+        break;
+      case PP_FONTFAMILY_SANSSERIF:
+        resolved_family = prefs.sans_serif_font_family;
+        break;
+      case PP_FONTFAMILY_MONOSPACE:
+        resolved_family = prefs.fixed_font_family;
+        break;
+      case PP_FONTFAMILY_DEFAULT:
+      default:
+        resolved_family = prefs.standard_font_family;
+        break;
+    }
+  } else {
+    // Use the exact font.
+    resolved_family = UTF8ToUTF16(face);
+  }
+  result.family = resolved_family;
+
   result.genericFamily = PP_FONTFAMILY_TO_WEB_FONTFAMILY(font.family);
-  result.size = static_cast<float>(font.size);
+
+  if (font.size == 0) {
+    // Resolve the default font size, using the resolved family to see if
+    // we should use the fixed or regular font size. It's difficult at this
+    // level to detect if the requested font is fixed width, so we only apply
+    // the alternate font size to the default fixed font family.
+    if (StringToLowerASCII(resolved_family) ==
+        StringToLowerASCII(prefs.fixed_font_family))
+      result.size = static_cast<float>(prefs.default_fixed_font_size);
+    else
+      result.size = static_cast<float>(prefs.default_font_size);
+  } else {
+    // Use the exact size.
+    result.size = static_cast<float>(font.size);
+  }
+
   result.italic = font.italic != PP_FALSE;
   result.smallCaps = font.small_caps != PP_FALSE;
   result.weight = static_cast<WebFontDescription::Weight>(font.weight);
   result.letterSpacing = static_cast<short>(font.letter_spacing);
   result.wordSpacing = static_cast<short>(font.word_spacing);
   return result;
 }
 
 WebTextRun TextRunToWebTextRun(const WebKitForwarding::Font::TextRun& run) {
   return WebTextRun(UTF8ToUTF16(run.text),
                     run.rtl != PP_FALSE,
                     run.override_direction != PP_FALSE);
 }
 
 // FontImpl --------------------------------------------------------------------
 
 class FontImpl : public WebKitForwarding::Font {
  public:
   FontImpl(const PP_FontDescription_Dev& desc,
-           const std::string& desc_face);
+           const std::string& desc_face,
+           const ::ppapi::Preferences& prefs);
   virtual ~FontImpl();
 
   virtual void Describe(base::WaitableEvent* event,
                         PP_FontDescription_Dev* description,
                         std::string* face,
                         PP_FontMetrics_Dev* metrics,
                         PP_Bool* result) OVERRIDE;
   virtual void DrawTextAt(base::WaitableEvent* event,
                           const DrawTextParams& params) OVERRIDE;
   virtual void MeasureText(base::WaitableEvent* event,
                            const TextRun& text,
                            int32_t* result) OVERRIDE;
   virtual void CharacterOffsetForPixel(base::WaitableEvent* event,
                                        const TextRun& text,
                                        int32_t pixel_position,
                                        uint32_t* result) OVERRIDE;
   virtual void PixelOffsetForCharacter(base::WaitableEvent* event,
                                        const TextRun& text,
                                        uint32_t char_offset,
                                        int32_t* result) OVERRIDE;
 
  private:
   scoped_ptr<WebFont> font_;
 
   DISALLOW_COPY_AND_ASSIGN(FontImpl);
 };
 
 FontImpl::FontImpl(const PP_FontDescription_Dev& desc,
-                   const std::string& desc_face) {
-  WebFontDescription web_font_desc = PPFontDescToWebFontDesc(desc, desc_face);
+                   const std::string& desc_face,
+                   const ::ppapi::Preferences& prefs) {
+  WebFontDescription web_font_desc = PPFontDescToWebFontDesc(desc, desc_face,
+                                                             prefs);
   font_.reset(WebFont::create(web_font_desc));
 }
 
 FontImpl::~FontImpl() {
 }
 
 void FontImpl::Describe(base::WaitableEvent* event,
                         PP_FontDescription_Dev* description,
                         std::string* face,
                         PP_FontMetrics_Dev* metrics,
@@ skipping 94 matching lines @@
 WebKitForwardingImpl::WebKitForwardingImpl() {
 }
 
 WebKitForwardingImpl::~WebKitForwardingImpl() {
 }
 
 void WebKitForwardingImpl::CreateFontForwarding(
     base::WaitableEvent* event,
     const PP_FontDescription_Dev& desc,
     const std::string& desc_face,
+    const ::ppapi::Preferences& prefs,
     Font** result) {
-  *result = new FontImpl(desc, desc_face);
+  *result = new FontImpl(desc, desc_face, prefs);
   if (event)
     event->Signal();
 }
 
 }  // namespace ppapi
 }  // namespace webkit