Refactor BrowserFont to new design

ppapi/proxy/browser_font_resource_trusted.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 "ppapi/shared_impl/private/ppb_browser_font_trusted_shared.h"
+#include "ppapi/proxy/browser_font_resource_trusted.h"
 
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "ppapi/c/dev/ppb_font_dev.h"
 #include "ppapi/shared_impl/ppapi_preferences.h"
 #include "ppapi/shared_impl/var.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/ppb_image_data_api.h"
 #include "ppapi/thunk/thunk.h"
 #include "skia/ext/platform_canvas.h"
-#include "third_party/skia/include/core/SkRect.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/WebTextRun.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebCanvas.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebFloatPoint.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebFloatRect.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebRect.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/WebTextRun.h"
+#include "third_party/skia/include/core/SkRect.h"
 #include "unicode/ubidi.h"
 
 using ppapi::StringVar;
 using ppapi::thunk::EnterResourceNoLock;
 using ppapi::thunk::PPB_ImageData_API;
 using WebKit::WebFloatPoint;
 using WebKit::WebFloatRect;
 using WebKit::WebFont;
 using WebKit::WebFontDescription;
 using WebKit::WebRect;
 using WebKit::WebTextRun;
 using WebKit::WebCanvas;
 
 namespace ppapi {
+namespace proxy {
 
 namespace {
 
 // Same as WebPreferences::kCommonScript. I'd use that directly here, but get an
 // undefined reference linker error.
 const char kCommonScript[] = "Zyyy";
 
 string16 GetFontFromMap(
     const webkit_glue::WebPreferences::ScriptFontFamilyMap& map,
     const std::string& script) {
@@ skipping 168 matching lines @@
   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;
 }
 
 }  // namespace
 
 // static
-bool PPB_BrowserFont_Trusted_Shared::IsPPFontDescriptionValid(
+bool BrowserFontResource_Trusted::IsPPFontDescriptionValid(
     const PP_BrowserFont_Trusted_Description& desc) {
   // Check validity of string. We can't check the actual text since we could
   // be on the wrong thread and don't know if we're in the plugin or the host.
   if (desc.face.type != PP_VARTYPE_STRING &&
       desc.face.type != PP_VARTYPE_UNDEFINED)
     return false;
 
   // Check enum ranges.
   if (static_cast<int>(desc.family) < PP_BROWSERFONT_TRUSTED_FAMILY_DEFAULT ||
       static_cast<int>(desc.family) > PP_BROWSERFONT_TRUSTED_FAMILY_MONOSPACE)
     return false;
   if (static_cast<int>(desc.weight) < PP_BROWSERFONT_TRUSTED_WEIGHT_100 ||
       static_cast<int>(desc.weight) > PP_BROWSERFONT_TRUSTED_WEIGHT_900)
     return false;
 
   // Check for excessive sizes which may cause layout to get confused.
   if (desc.size > 200)
     return false;
 
   return true;
 }
 
-// static
-PP_Resource PPB_BrowserFont_Trusted_Shared::Create(
-    ResourceObjectType type,
-    PP_Instance instance,
-    const PP_BrowserFont_Trusted_Description& description,
-    const Preferences& prefs) {
-  if (!PPB_BrowserFont_Trusted_Shared::IsPPFontDescriptionValid(description))
-    return 0;
-  return (new PPB_BrowserFont_Trusted_Shared(type, instance,
-                                             description,
-                                             prefs))->GetReference();
-}
-
-PPB_BrowserFont_Trusted_Shared::PPB_BrowserFont_Trusted_Shared(
-    ResourceObjectType type,
+BrowserFontResource_Trusted::BrowserFontResource_Trusted(
+    Connection connection,
     PP_Instance instance,
     const PP_BrowserFont_Trusted_Description& desc,
     const Preferences& prefs)
-    : Resource(type, instance),
+    : PluginResource(connection, instance),
       font_(WebFont::create(PPFontDescToWebFontDesc(desc, prefs))) {
 }
 
-PPB_BrowserFont_Trusted_Shared::~PPB_BrowserFont_Trusted_Shared() {
+BrowserFontResource_Trusted::~BrowserFontResource_Trusted() {
 }
 
 thunk::PPB_BrowserFont_Trusted_API*
-PPB_BrowserFont_Trusted_Shared::AsPPB_BrowserFont_Trusted_API() {
+BrowserFontResource_Trusted::AsPPB_BrowserFont_Trusted_API() {
   return this;
 }
 
-PP_Bool PPB_BrowserFont_Trusted_Shared::Describe(
+PP_Bool BrowserFontResource_Trusted::Describe(
     PP_BrowserFont_Trusted_Description* description,
     PP_BrowserFont_Trusted_Metrics* metrics) {
   if (description->face.type != PP_VARTYPE_UNDEFINED)
     return PP_FALSE;
 
   // While converting the other way in PPFontDescToWebFontDesc we validated
   // that the enums can be casted.
   WebFontDescription web_desc = font_->fontDescription();
   description->face = StringVar::StringToPPVar(UTF16ToUTF8(web_desc.family));
   description->family =
       static_cast<PP_BrowserFont_Trusted_Family>(web_desc.genericFamily);
   description->size = static_cast<uint32_t>(web_desc.size);
   description->weight = static_cast<PP_BrowserFont_Trusted_Weight>(
       web_desc.weight);
   description->italic = web_desc.italic ? PP_TRUE : PP_FALSE;
   description->small_caps = web_desc.smallCaps ? PP_TRUE : PP_FALSE;
   description->letter_spacing = static_cast<int32_t>(web_desc.letterSpacing);
   description->word_spacing = static_cast<int32_t>(web_desc.wordSpacing);
 
   metrics->height = font_->height();
   metrics->ascent = font_->ascent();
   metrics->descent = font_->descent();
   metrics->line_spacing = font_->lineSpacing();
   metrics->x_height = static_cast<int32_t>(font_->xHeight());
 
   // Convert the string.
   return PP_TRUE;
 }
 
-PP_Bool PPB_BrowserFont_Trusted_Shared::DrawTextAt(
+PP_Bool BrowserFontResource_Trusted::DrawTextAt(
     PP_Resource image_data,
     const PP_BrowserFont_Trusted_TextRun* text,
     const PP_Point* position,
     uint32_t color,
     const PP_Rect* clip,
     PP_Bool image_data_is_opaque) {
   PP_Bool result = PP_FALSE;
   // Get and map the image data we're painting to.
   EnterResourceNoLock<PPB_ImageData_API> enter(image_data, true);
   if (enter.failed())
@@ skipping 11 matching lines @@
       return result;  // Failure mapping.
   }
 
   DrawTextToCanvas(canvas, *text, position, color, clip, image_data_is_opaque);
 
   if (needs_unmapping)
     image->Unmap();
   return PP_TRUE;
 }
 
-int32_t PPB_BrowserFont_Trusted_Shared::MeasureText(
+int32_t BrowserFontResource_Trusted::MeasureText(
     const PP_BrowserFont_Trusted_TextRun* text) {
   WebTextRun run;
   if (!PPTextRunToWebTextRun(*text, &run))
     return -1;
   return font_->calculateWidth(run);
 }
 
-uint32_t PPB_BrowserFont_Trusted_Shared::CharacterOffsetForPixel(
+uint32_t BrowserFontResource_Trusted::CharacterOffsetForPixel(
     const PP_BrowserFont_Trusted_TextRun* text,
     int32_t pixel_position) {
   TextRunCollection runs(*text);
   int32_t cur_pixel_offset = 0;
   for (int i = 0; i < runs.num_runs(); i++) {
     int32_t run_begin = 0;
     int32_t run_len = 0;
     WebTextRun run = runs.GetRunAt(i, &run_begin, &run_len);
     int run_width = font_->calculateWidth(run);
     if (pixel_position < cur_pixel_offset + run_width) {
       // Offset is in this run.
       return static_cast<uint32_t>(font_->offsetForPosition(
               run, static_cast<float>(pixel_position - cur_pixel_offset))) +
           run_begin;
     }
     cur_pixel_offset += run_width;
   }
   return runs.text().size();
 }
 
-int32_t PPB_BrowserFont_Trusted_Shared::PixelOffsetForCharacter(
+int32_t BrowserFontResource_Trusted::PixelOffsetForCharacter(
     const PP_BrowserFont_Trusted_TextRun* text,
     uint32_t char_offset) {
   TextRunCollection runs(*text);
   int32_t cur_pixel_offset = 0;
   for (int i = 0; i < runs.num_runs(); i++) {
     int32_t run_begin = 0;
     int32_t run_len = 0;
     WebTextRun run = runs.GetRunAt(i, &run_begin, &run_len);
     if (char_offset >= static_cast<uint32_t>(run_begin) &&
         char_offset < static_cast<uint32_t>(run_begin + run_len)) {
@@ skipping 10 matching lines @@
       return cur_pixel_offset + static_cast<int>(rect.x);
     } else {
       // Character is past this run, account for the pixels and continue
       // looking.
       cur_pixel_offset += font_->calculateWidth(run);
     }
   }
   return -1;  // Requested a char beyond the end.
 }
 
-void PPB_BrowserFont_Trusted_Shared::DrawTextToCanvas(
+void BrowserFontResource_Trusted::DrawTextToCanvas(
     SkCanvas* destination,
     const PP_BrowserFont_Trusted_TextRun& text,
     const PP_Point* position,
     uint32_t color,
     const PP_Rect* clip,
     PP_Bool image_data_is_opaque) {
   // Convert position and clip.
   WebFloatPoint web_position(static_cast<float>(position->x),
                              static_cast<float>(position->y));
   WebRect web_clip;
@@ skipping 18 matching lines @@
                     PP_ToBool(image_data_is_opaque));
 
     // Advance to the next run. Note that we avoid doing this for the last run
     // since it's unnecessary, measuring text is slow, and most of the time
     // there will be only one run anyway.
     if (i != runs.num_runs() - 1)
       web_position.x += font_->calculateWidth(run);
   }
 }
 
+}  // namespace proxy
 }  // namespace ppapi