src/content/renderer/pepper/pepper_truetype_font_win.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/renderer/pepper/pepper_truetype_font.h"
   6
   7 #include <windows.h>
   8 #include <set>
   9
  10 #include "base/compiler_specific.h"
  11 #include "base/memory/scoped_ptr.h"
  12 #include "base/strings/utf_string_conversions.h"
  13 #include "base/sys_byteorder.h"
  14 #include "base/win/scoped_hdc.h"
  15 #include "base/win/scoped_select_object.h"
  16 #include "content/public/renderer/render_thread.h"
  17 #include "ppapi/c/dev/ppb_truetype_font_dev.h"
  18 #include "ppapi/c/pp_errors.h"
  19
  20 namespace content {
  21
  22 namespace {
  23
  24 class PepperTrueTypeFontWin : public PepperTrueTypeFont {
  25  public:
  26   explicit PepperTrueTypeFontWin(
  27       const ppapi::proxy::SerializedTrueTypeFontDesc& desc);
  28   virtual ~PepperTrueTypeFontWin();
  29
  30   // PepperTrueTypeFont overrides.
  31   virtual bool IsValid() OVERRIDE;
  32   virtual int32_t Describe(
  33       ppapi::proxy::SerializedTrueTypeFontDesc* desc) OVERRIDE;
  34   virtual int32_t GetTableTags(std::vector<uint32_t>* tags) OVERRIDE;
  35   virtual int32_t GetTable(uint32_t table_tag,
  36                            int32_t offset,
  37                            int32_t max_data_length,
  38                            std::string* data) OVERRIDE;
  39  private:
  40   DWORD GetFontData(HDC hdc,
  41                     DWORD table,
  42                     DWORD offset,
  43                     LPVOID buffer,
  44                     DWORD length);
  45
  46   HFONT font_;
  47
  48   DISALLOW_COPY_AND_ASSIGN(PepperTrueTypeFontWin);
  49 };
  50
  51 PepperTrueTypeFontWin::PepperTrueTypeFontWin(
  52     const ppapi::proxy::SerializedTrueTypeFontDesc& desc) {
  53   DWORD pitch_and_family = DEFAULT_PITCH;
  54   switch (desc.generic_family) {
  55     case PP_TRUETYPEFONTFAMILY_SERIF:
  56       pitch_and_family |= FF_ROMAN;
  57       break;
  58     case PP_TRUETYPEFONTFAMILY_SANSSERIF:
  59       pitch_and_family |= FF_SWISS;
  60       break;
  61     case PP_TRUETYPEFONTFAMILY_CURSIVE:
  62       pitch_and_family |= FF_SCRIPT;
  63       break;
  64     case PP_TRUETYPEFONTFAMILY_FANTASY:
  65       pitch_and_family |= FF_DECORATIVE;
  66       break;
  67     case PP_TRUETYPEFONTFAMILY_MONOSPACE:
  68       pitch_and_family |= FF_MODERN;
  69       break;
  70   }
  71   // TODO(bbudge) support widths (extended, condensed).
  72
  73   font_ = CreateFont(0  /* height */,
  74                      0  /* width */,
  75                      0  /* escapement */,
  76                      0  /* orientation */,
  77                      desc.weight,  // our weight enum matches Windows.
  78                      (desc.style & PP_TRUETYPEFONTSTYLE_ITALIC) ? 1 : 0,
  79                      0  /* underline */,
  80                      0  /* strikeout */,
  81                      desc.charset,  // our charset enum matches Windows.
  82                      OUT_OUTLINE_PRECIS,  // truetype and other outline fonts
  83                      CLIP_DEFAULT_PRECIS,
  84                      DEFAULT_QUALITY,
  85                      pitch_and_family,
  86                      UTF8ToUTF16(desc.family).c_str());
  87 }
  88
  89 PepperTrueTypeFontWin::~PepperTrueTypeFontWin() {
  90 }
  91
  92 bool PepperTrueTypeFontWin::IsValid() {
  93   return font_ != NULL;
  94 }
  95
  96 int32_t PepperTrueTypeFontWin::Describe(
  97       ppapi::proxy::SerializedTrueTypeFontDesc* desc) {
  98   LOGFONT font_desc;
  99   if (!::GetObject(font_, sizeof(LOGFONT), &font_desc))
 100     return PP_ERROR_FAILED;
 101
 102   switch (font_desc.lfPitchAndFamily & 0xF0) {  // Top 4 bits are family.
 103     case FF_ROMAN:
 104       desc->generic_family = PP_TRUETYPEFONTFAMILY_SERIF;
 105       break;
 106     case FF_SWISS:
 107       desc->generic_family = PP_TRUETYPEFONTFAMILY_SANSSERIF;
 108       break;
 109     case FF_SCRIPT:
 110       desc->generic_family = PP_TRUETYPEFONTFAMILY_CURSIVE;
 111       break;
 112     case FF_DECORATIVE:
 113       desc->generic_family = PP_TRUETYPEFONTFAMILY_FANTASY;
 114       break;
 115     case FF_MODERN:
 116       desc->generic_family = PP_TRUETYPEFONTFAMILY_MONOSPACE;
 117       break;
 118   }
 119
 120   desc->style = font_desc.lfItalic ? PP_TRUETYPEFONTSTYLE_ITALIC :
 121                                      PP_TRUETYPEFONTSTYLE_NORMAL;
 122   desc->weight = static_cast<PP_TrueTypeFontWeight_Dev>(font_desc.lfWeight);
 123   desc->width = PP_TRUETYPEFONTWIDTH_NORMAL;
 124   desc->charset =
 125       static_cast<PP_TrueTypeFontCharset_Dev>(font_desc.lfCharSet);
 126
 127   // To get the face name, select the font and query for the name. GetObject
 128   // doesn't fill in the name field of the LOGFONT structure.
 129   base::win::ScopedCreateDC hdc(::CreateCompatibleDC(NULL));
 130   if (hdc) {
 131     base::win::ScopedSelectObject select_object(hdc, font_);
 132     WCHAR name[LF_FACESIZE];
 133     GetTextFace(hdc, LF_FACESIZE, name);
 134     desc->family = UTF16ToUTF8(name);
 135   }
 136   return PP_OK;
 137 }
 138
 139 DWORD PepperTrueTypeFontWin::GetFontData(HDC hdc,
 140                                          DWORD table,
 141                                          DWORD offset,
 142                                          void* buffer,
 143                                          DWORD length) {
 144   // If this is a zero byte read, return a successful result.
 145   if (buffer && !length)
 146     return 0;
 147
 148   DWORD result = ::GetFontData(hdc, table, offset, buffer, length);
 149   if (result == GDI_ERROR) {
 150     // The font may not be cached by the OS, causing an attempt to read it in
 151     // the renderer process to fail. Attempt to pre-cache it.
 152     LOGFONTW logfont;
 153     if (!::GetObject(font_, sizeof(LOGFONTW), &logfont))
 154       return GDI_ERROR;
 155     RenderThread* render_thread = RenderThread::Get();
 156     if (!render_thread)
 157       return GDI_ERROR;
 158     render_thread->PreCacheFont(logfont);
 159
 160     result = ::GetFontData(hdc, table, offset, buffer, length);
 161   }
 162   return result;
 163 }
 164
 165 int32_t PepperTrueTypeFontWin::GetTableTags(std::vector<uint32_t>* tags) {
 166   base::win::ScopedCreateDC hdc(::CreateCompatibleDC(NULL));
 167   if (!hdc)
 168     return PP_ERROR_FAILED;
 169
 170   base::win::ScopedSelectObject select_object(hdc, font_);
 171
 172   // Get the whole font header.
 173   static const DWORD kFontHeaderSize = 12;
 174   uint8_t header_buf[kFontHeaderSize];
 175   if (GetFontData(hdc, 0, 0, header_buf, kFontHeaderSize) == GDI_ERROR)
 176     return PP_ERROR_FAILED;
 177
 178   // The numTables follows a 4 byte scalerType tag. Font data is stored in
 179   // big-endian order.
 180   DWORD num_tables = (header_buf[4] << 8) | header_buf[5];
 181
 182   // The size in bytes of an entry in the table directory.
 183   static const DWORD kDirectoryEntrySize = 16;
 184   DWORD directory_size = num_tables * kDirectoryEntrySize;
 185   scoped_ptr<uint8_t[]> directory(new uint8_t[directory_size]);
 186   // Get the table directory entries after the font header.
 187   if (GetFontData(hdc, 0 /* tag */, kFontHeaderSize,
 188                   directory.get(),
 189                   directory_size) == GDI_ERROR)
 190     return PP_ERROR_FAILED;
 191
 192   tags->resize(num_tables);
 193   for (DWORD i = 0; i < num_tables; i++) {
 194     const uint8_t* entry = directory.get() + i * kDirectoryEntrySize;
 195     uint32_t tag = static_cast<uint32_t>(entry[0]) << 24 |
 196                    static_cast<uint32_t>(entry[1]) << 16 |
 197                    static_cast<uint32_t>(entry[2]) << 8  |
 198                    static_cast<uint32_t>(entry[3]);
 199     (*tags)[i] = tag;
 200   }
 201
 202   return num_tables;
 203 }
 204
 205 int32_t PepperTrueTypeFontWin::GetTable(uint32_t table_tag,
 206                                         int32_t offset,
 207                                         int32_t max_data_length,
 208                                         std::string* data) {
 209   base::win::ScopedCreateDC hdc(::CreateCompatibleDC(NULL));
 210   if (!hdc)
 211     return PP_ERROR_FAILED;
 212
 213   base::win::ScopedSelectObject select_object(hdc, font_);
 214
 215   // Tags are byte swapped on Windows.
 216   table_tag = base::ByteSwap(table_tag);
 217   // Get the size of the font table first.
 218   DWORD table_size = GetFontData(hdc, table_tag, 0, NULL, 0);
 219   if (table_size == GDI_ERROR)
 220     return PP_ERROR_FAILED;
 221
 222   DWORD safe_offset = std::min(static_cast<DWORD>(offset), table_size);
 223   DWORD safe_length = std::min(table_size - safe_offset,
 224                                static_cast<DWORD>(max_data_length));
 225   data->resize(safe_length);
 226   if (safe_length == 0) {
 227     table_size = 0;
 228   } else {
 229     table_size = GetFontData(hdc, table_tag, safe_offset,
 230                              reinterpret_cast<uint8_t*>(&(*data)[0]),
 231                              safe_length);
 232     if (table_size == GDI_ERROR)
 233       return PP_ERROR_FAILED;
 234   }
 235   return static_cast<int32_t>(table_size);
 236 }
 237
 238 }  // namespace
 239
 240 // static
 241 PepperTrueTypeFont* PepperTrueTypeFont::Create(
 242     const ppapi::proxy::SerializedTrueTypeFontDesc& desc) {
 243   return new PepperTrueTypeFontWin(desc);
 244 }
 245
 246 }  // namespace content