1 // Copyright (c) 2012 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/child/browser_font_resource_trusted.h" 6 7 #include "base/strings/string_util.h" 8 #include "base/strings/utf_string_conversions.h" 9 #include "content/public/common/web_preferences.h" 10 #include "ppapi/c/dev/ppb_font_dev.h" 11 #include "ppapi/proxy/connection.h" 12 #include "ppapi/shared_impl/ppapi_preferences.h" 13 #include "ppapi/shared_impl/var.h" 14 #include "ppapi/thunk/enter.h" 15 #include "ppapi/thunk/ppb_image_data_api.h" 16 #include "ppapi/thunk/thunk.h" 17 #include "skia/ext/platform_canvas.h" 18 #include "third_party/WebKit/public/platform/WebCanvas.h" 19 #include "third_party/WebKit/public/platform/WebFloatPoint.h" 20 #include "third_party/WebKit/public/platform/WebFloatRect.h" 21 #include "third_party/WebKit/public/platform/WebRect.h" 22 #include "third_party/WebKit/public/web/WebFont.h" 23 #include "third_party/WebKit/public/web/WebFontDescription.h" 24 #include "third_party/WebKit/public/web/WebTextRun.h" 25 #include "third_party/icu/source/common/unicode/ubidi.h" 26 #include "third_party/skia/include/core/SkRect.h" 27 28 using ppapi::StringVar; 29 using ppapi::thunk::EnterResourceNoLock; 30 using ppapi::thunk::PPB_ImageData_API; 31 using blink::WebFloatPoint; 32 using blink::WebFloatRect; 33 using blink::WebFont; 34 using blink::WebFontDescription; 35 using blink::WebRect; 36 using blink::WebTextRun; 37 using blink::WebCanvas; 38 39 namespace content { 40 41 namespace { 42 43 // Same as WebPreferences::kCommonScript. I'd use that directly here, but get an 44 // undefined reference linker error. 45 const char kCommonScript[] = "Zyyy"; 46 47 base::string16 GetFontFromMap(const ScriptFontFamilyMap& map, 48 const std::string& script) { 49 ScriptFontFamilyMap::const_iterator it = map.find(script); 50 if (it != map.end()) 51 return it->second; 52 return base::string16(); 53 } 54 55 // Splits a PP_BrowserFont_Trusted_TextRun into a sequence or LTR and RTL 56 // WebTextRuns that can be used for WebKit. Normally WebKit does this for us, 57 // but the font drawing and measurement routines we call happen after this 58 // step. So for correct rendering of RTL content, we need to do it ourselves. 59 class TextRunCollection { 60 public: 61 explicit TextRunCollection(const PP_BrowserFont_Trusted_TextRun& run) 62 : bidi_(NULL), 63 num_runs_(0) { 64 StringVar* text_string = StringVar::FromPPVar(run.text); 65 if (!text_string) 66 return; // Leave num_runs_ = 0 so we'll do nothing. 67 text_ = base::UTF8ToUTF16(text_string->value()); 68 69 if (run.override_direction) { 70 // Skip autodetection. 71 num_runs_ = 1; 72 override_run_ = WebTextRun(text_, PP_ToBool(run.rtl), true); 73 } else { 74 bidi_ = ubidi_open(); 75 UErrorCode uerror = U_ZERO_ERROR; 76 ubidi_setPara(bidi_, text_.data(), text_.size(), run.rtl, NULL, &uerror); 77 if (U_SUCCESS(uerror)) 78 num_runs_ = ubidi_countRuns(bidi_, &uerror); 79 } 80 } 81 82 ~TextRunCollection() { 83 if (bidi_) 84 ubidi_close(bidi_); 85 } 86 87 const base::string16& text() const { return text_; } 88 int num_runs() const { return num_runs_; } 89 90 // Returns a WebTextRun with the info for the run at the given index. 91 // The range covered by the run is in the two output params. 92 WebTextRun GetRunAt(int index, int32_t* run_start, int32_t* run_len) const { 93 DCHECK(index < num_runs_); 94 if (bidi_) { 95 bool run_rtl = !!ubidi_getVisualRun(bidi_, index, run_start, run_len); 96 return WebTextRun(base::string16(&text_[*run_start], *run_len), 97 run_rtl, true); 98 } 99 100 // Override run, return the single one. 101 DCHECK(index == 0); 102 *run_start = 0; 103 *run_len = static_cast<int32_t>(text_.size()); 104 return override_run_; 105 } 106 107 private: 108 // Will be null if we skipped autodetection. 109 UBiDi* bidi_; 110 111 // Text of all the runs. 112 base::string16 text_; 113 114 int num_runs_; 115 116 // When the content specifies override_direction (bidi_ is null) then this 117 // will contain the single text run for WebKit. 118 WebTextRun override_run_; 119 120 DISALLOW_COPY_AND_ASSIGN(TextRunCollection); 121 }; 122 123 bool PPTextRunToWebTextRun(const PP_BrowserFont_Trusted_TextRun& text, 124 WebTextRun* run) { 125 StringVar* text_string = StringVar::FromPPVar(text.text); 126 if (!text_string) 127 return false; 128 129 *run = WebTextRun(base::UTF8ToUTF16(text_string->value()), 130 PP_ToBool(text.rtl), 131 PP_ToBool(text.override_direction)); 132 return true; 133 } 134 135 // The PP_* version lacks "None", so is just one value shifted from the 136 // WebFontDescription version. These values are checked in 137 // PPFontDescToWebFontDesc to make sure the conversion is correct. This is a 138 // macro so it can also be used in the COMPILE_ASSERTS. 139 #define PP_FAMILY_TO_WEB_FAMILY(f) \ 140 static_cast<WebFontDescription::GenericFamily>(f + 1) 141 142 // Assumes the given PP_FontDescription has been validated. 143 WebFontDescription PPFontDescToWebFontDesc( 144 const PP_BrowserFont_Trusted_Description& font, 145 const ppapi::Preferences& prefs) { 146 // Verify that the enums match so we can just static cast. 147 COMPILE_ASSERT(static_cast<int>(WebFontDescription::Weight100) == 148 static_cast<int>(PP_BROWSERFONT_TRUSTED_WEIGHT_100), 149 FontWeight100); 150 COMPILE_ASSERT(static_cast<int>(WebFontDescription::Weight900) == 151 static_cast<int>(PP_BROWSERFONT_TRUSTED_WEIGHT_900), 152 FontWeight900); 153 COMPILE_ASSERT(WebFontDescription::GenericFamilyStandard == 154 PP_FAMILY_TO_WEB_FAMILY(PP_FONTFAMILY_DEFAULT), 155 StandardFamily); 156 COMPILE_ASSERT(WebFontDescription::GenericFamilySerif == 157 PP_FAMILY_TO_WEB_FAMILY(PP_FONTFAMILY_SERIF), 158 SerifFamily); 159 COMPILE_ASSERT(WebFontDescription::GenericFamilySansSerif == 160 PP_FAMILY_TO_WEB_FAMILY(PP_FONTFAMILY_SANSSERIF), 161 SansSerifFamily); 162 COMPILE_ASSERT(WebFontDescription::GenericFamilyMonospace == 163 PP_FAMILY_TO_WEB_FAMILY(PP_FONTFAMILY_MONOSPACE), 164 MonospaceFamily); 165 166 StringVar* face_name = StringVar::FromPPVar(font.face); // Possibly null. 167 168 WebFontDescription result; 169 base::string16 resolved_family; 170 if (!face_name || face_name->value().empty()) { 171 // Resolve the generic family. 172 switch (font.family) { 173 case PP_BROWSERFONT_TRUSTED_FAMILY_SERIF: 174 resolved_family = GetFontFromMap(prefs.serif_font_family_map, 175 kCommonScript); 176 break; 177 case PP_BROWSERFONT_TRUSTED_FAMILY_SANSSERIF: 178 resolved_family = GetFontFromMap(prefs.sans_serif_font_family_map, 179 kCommonScript); 180 break; 181 case PP_BROWSERFONT_TRUSTED_FAMILY_MONOSPACE: 182 resolved_family = GetFontFromMap(prefs.fixed_font_family_map, 183 kCommonScript); 184 break; 185 case PP_BROWSERFONT_TRUSTED_FAMILY_DEFAULT: 186 default: 187 resolved_family = GetFontFromMap(prefs.standard_font_family_map, 188 kCommonScript); 189 break; 190 } 191 } else { 192 // Use the exact font. 193 resolved_family = base::UTF8ToUTF16(face_name->value()); 194 } 195 result.family = resolved_family; 196 197 result.genericFamily = PP_FAMILY_TO_WEB_FAMILY(font.family); 198 199 if (font.size == 0) { 200 // Resolve the default font size, using the resolved family to see if 201 // we should use the fixed or regular font size. It's difficult at this 202 // level to detect if the requested font is fixed width, so we only apply 203 // the alternate font size to the default fixed font family. 204 if (base::StringToLowerASCII(resolved_family) == 205 base::StringToLowerASCII(GetFontFromMap(prefs.fixed_font_family_map, 206 kCommonScript))) 207 result.size = static_cast<float>(prefs.default_fixed_font_size); 208 else 209 result.size = static_cast<float>(prefs.default_font_size); 210 } else { 211 // Use the exact size. 212 result.size = static_cast<float>(font.size); 213 } 214 215 result.italic = font.italic != PP_FALSE; 216 result.smallCaps = font.small_caps != PP_FALSE; 217 result.weight = static_cast<WebFontDescription::Weight>(font.weight); 218 result.letterSpacing = static_cast<short>(font.letter_spacing); 219 result.wordSpacing = static_cast<short>(font.word_spacing); 220 return result; 221 } 222 223 } // namespace 224 225 // static 226 bool BrowserFontResource_Trusted::IsPPFontDescriptionValid( 227 const PP_BrowserFont_Trusted_Description& desc) { 228 // Check validity of string. We can't check the actual text since we could 229 // be on the wrong thread and don't know if we're in the plugin or the host. 230 if (desc.face.type != PP_VARTYPE_STRING && 231 desc.face.type != PP_VARTYPE_UNDEFINED) 232 return false; 233 234 // Check enum ranges. 235 if (static_cast<int>(desc.family) < PP_BROWSERFONT_TRUSTED_FAMILY_DEFAULT || 236 static_cast<int>(desc.family) > PP_BROWSERFONT_TRUSTED_FAMILY_MONOSPACE) 237 return false; 238 if (static_cast<int>(desc.weight) < PP_BROWSERFONT_TRUSTED_WEIGHT_100 || 239 static_cast<int>(desc.weight) > PP_BROWSERFONT_TRUSTED_WEIGHT_900) 240 return false; 241 242 // Check for excessive sizes which may cause layout to get confused. 243 if (desc.size > 200) 244 return false; 245 246 return true; 247 } 248 249 BrowserFontResource_Trusted::BrowserFontResource_Trusted( 250 ppapi::proxy::Connection connection, 251 PP_Instance instance, 252 const PP_BrowserFont_Trusted_Description& desc, 253 const ppapi::Preferences& prefs) 254 : PluginResource(connection, instance), 255 font_(WebFont::create(PPFontDescToWebFontDesc(desc, prefs))) { 256 } 257 258 BrowserFontResource_Trusted::~BrowserFontResource_Trusted() { 259 } 260 261 ppapi::thunk::PPB_BrowserFont_Trusted_API* 262 BrowserFontResource_Trusted::AsPPB_BrowserFont_Trusted_API() { 263 return this; 264 } 265 266 PP_Bool BrowserFontResource_Trusted::Describe( 267 PP_BrowserFont_Trusted_Description* description, 268 PP_BrowserFont_Trusted_Metrics* metrics) { 269 if (description->face.type != PP_VARTYPE_UNDEFINED) 270 return PP_FALSE; 271 272 // While converting the other way in PPFontDescToWebFontDesc we validated 273 // that the enums can be casted. 274 WebFontDescription web_desc = font_->fontDescription(); 275 description->face = 276 StringVar::StringToPPVar(base::UTF16ToUTF8(web_desc.family)); 277 description->family = 278 static_cast<PP_BrowserFont_Trusted_Family>(web_desc.genericFamily); 279 description->size = static_cast<uint32_t>(web_desc.size); 280 description->weight = static_cast<PP_BrowserFont_Trusted_Weight>( 281 web_desc.weight); 282 description->italic = web_desc.italic ? PP_TRUE : PP_FALSE; 283 description->small_caps = web_desc.smallCaps ? PP_TRUE : PP_FALSE; 284 description->letter_spacing = static_cast<int32_t>(web_desc.letterSpacing); 285 description->word_spacing = static_cast<int32_t>(web_desc.wordSpacing); 286 287 metrics->height = font_->height(); 288 metrics->ascent = font_->ascent(); 289 metrics->descent = font_->descent(); 290 metrics->line_spacing = font_->lineSpacing(); 291 metrics->x_height = static_cast<int32_t>(font_->xHeight()); 292 293 // Convert the string. 294 return PP_TRUE; 295 } 296 297 PP_Bool BrowserFontResource_Trusted::DrawTextAt( 298 PP_Resource image_data, 299 const PP_BrowserFont_Trusted_TextRun* text, 300 const PP_Point* position, 301 uint32_t color, 302 const PP_Rect* clip, 303 PP_Bool image_data_is_opaque) { 304 PP_Bool result = PP_FALSE; 305 // Get and map the image data we're painting to. 306 EnterResourceNoLock<PPB_ImageData_API> enter(image_data, true); 307 if (enter.failed()) 308 return result; 309 310 PPB_ImageData_API* image = static_cast<PPB_ImageData_API*>( 311 enter.object()); 312 SkCanvas* canvas = image->GetPlatformCanvas(); 313 bool needs_unmapping = false; 314 if (!canvas) { 315 needs_unmapping = true; 316 image->Map(); 317 canvas = image->GetPlatformCanvas(); 318 if (!canvas) 319 return result; // Failure mapping. 320 } 321 322 DrawTextToCanvas(canvas, *text, position, color, clip, image_data_is_opaque); 323 324 if (needs_unmapping) 325 image->Unmap(); 326 return PP_TRUE; 327 } 328 329 int32_t BrowserFontResource_Trusted::MeasureText( 330 const PP_BrowserFont_Trusted_TextRun* text) { 331 WebTextRun run; 332 if (!PPTextRunToWebTextRun(*text, &run)) 333 return -1; 334 return font_->calculateWidth(run); 335 } 336 337 uint32_t BrowserFontResource_Trusted::CharacterOffsetForPixel( 338 const PP_BrowserFont_Trusted_TextRun* text, 339 int32_t pixel_position) { 340 TextRunCollection runs(*text); 341 int32_t cur_pixel_offset = 0; 342 for (int i = 0; i < runs.num_runs(); i++) { 343 int32_t run_begin = 0; 344 int32_t run_len = 0; 345 WebTextRun run = runs.GetRunAt(i, &run_begin, &run_len); 346 int run_width = font_->calculateWidth(run); 347 if (pixel_position < cur_pixel_offset + run_width) { 348 // Offset is in this run. 349 return static_cast<uint32_t>(font_->offsetForPosition( 350 run, static_cast<float>(pixel_position - cur_pixel_offset))) + 351 run_begin; 352 } 353 cur_pixel_offset += run_width; 354 } 355 return runs.text().size(); 356 } 357 358 int32_t BrowserFontResource_Trusted::PixelOffsetForCharacter( 359 const PP_BrowserFont_Trusted_TextRun* text, 360 uint32_t char_offset) { 361 TextRunCollection runs(*text); 362 int32_t cur_pixel_offset = 0; 363 for (int i = 0; i < runs.num_runs(); i++) { 364 int32_t run_begin = 0; 365 int32_t run_len = 0; 366 WebTextRun run = runs.GetRunAt(i, &run_begin, &run_len); 367 if (char_offset >= static_cast<uint32_t>(run_begin) && 368 char_offset < static_cast<uint32_t>(run_begin + run_len)) { 369 // Character we're looking for is in this run. 370 // 371 // Here we ask WebKit to give us the rectangle around the character in 372 // question, and then return the left edge. If we asked for a range of 373 // 0 characters starting at the character in question, it would give us 374 // a 0-width rect around the insertion point. But that will be on the 375 // right side of the character for an RTL run, which would be wrong. 376 WebFloatRect rect = font_->selectionRectForText( 377 run, WebFloatPoint(0.0f, 0.0f), font_->height(), 378 char_offset - run_begin, char_offset - run_begin + 1); 379 return cur_pixel_offset + static_cast<int>(rect.x); 380 } else { 381 // Character is past this run, account for the pixels and continue 382 // looking. 383 cur_pixel_offset += font_->calculateWidth(run); 384 } 385 } 386 return -1; // Requested a char beyond the end. 387 } 388 389 void BrowserFontResource_Trusted::DrawTextToCanvas( 390 SkCanvas* destination, 391 const PP_BrowserFont_Trusted_TextRun& text, 392 const PP_Point* position, 393 uint32_t color, 394 const PP_Rect* clip, 395 PP_Bool image_data_is_opaque) { 396 // Convert position and clip. 397 WebFloatPoint web_position(static_cast<float>(position->x), 398 static_cast<float>(position->y)); 399 WebRect web_clip; 400 if (!clip) { 401 // Use entire canvas. SkCanvas doesn't have a size on it, so we just use 402 // the current clip bounds. 403 SkRect skclip; 404 destination->getClipBounds(&skclip); 405 web_clip = WebRect(skclip.fLeft, skclip.fTop, skclip.fRight - skclip.fLeft, 406 skclip.fBottom - skclip.fTop); 407 } else { 408 web_clip = WebRect(clip->point.x, clip->point.y, 409 clip->size.width, clip->size.height); 410 } 411 412 TextRunCollection runs(text); 413 for (int i = 0; i < runs.num_runs(); i++) { 414 int32_t run_begin = 0; 415 int32_t run_len = 0; 416 WebTextRun run = runs.GetRunAt(i, &run_begin, &run_len); 417 font_->drawText(destination, run, web_position, color, web_clip, 418 PP_ToBool(image_data_is_opaque)); 419 420 // Advance to the next run. Note that we avoid doing this for the last run 421 // since it's unnecessary, measuring text is slow, and most of the time 422 // there will be only one run anyway. 423 if (i != runs.num_runs() - 1) 424 web_position.x += font_->calculateWidth(run); 425 } 426 } 427 428 } // namespace content 429
