Make PPAPI headers compile with C compilers (gcc on Linux & Mac and MSVS on W...

webkit/glue/plugins/pepper_font.cc

 // Copyright (c) 2010 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/glue/plugins/pepper_font.h"
 
 #include "base/logging.h"
 #include "base/utf_string_conversions.h"
 #include "ppapi/c/dev/ppb_font_dev.h"
 #include "ppapi/c/pp_rect.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebFont.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebFontDescription.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebRect.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebFloatPoint.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebFloatRect.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebTextRun.h"
+#include "webkit/glue/plugins/pepper_common.h"
 #include "webkit/glue/plugins/pepper_image_data.h"
 #include "webkit/glue/plugins/pepper_plugin_module.h"
 #include "webkit/glue/plugins/pepper_string.h"
 #include "webkit/glue/plugins/pepper_var.h"
 #include "webkit/glue/webkit_glue.h"
 
 using WebKit::WebFloatPoint;
 using WebKit::WebFloatRect;
 using WebKit::WebFont;
 using WebKit::WebFontDescription;
@@ skipping 53 matching lines @@
   COMPILE_ASSERT(WebFontDescription::GenericFamilyMonospace ==
                  PP_FONTFAMILY_TO_WEB_FONTFAMILY(PP_FONTFAMILY_MONOSPACE),
                  MonospaceFamily);
 
   WebFontDescription result;
   scoped_refptr<StringVar> face_name(StringVar::FromPPVar(font.face));
   if (face_name)
     result.family = UTF8ToUTF16(face_name->value());
   result.genericFamily = PP_FONTFAMILY_TO_WEB_FONTFAMILY(font.family);
   result.size = static_cast<float>(font.size);
-  result.italic = font.italic;
-  result.smallCaps = font.small_caps;
+  result.italic = PPBoolToBool(font.italic);
+  result.smallCaps = PPBoolToBool(font.small_caps);
   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;
 }
 
 // Converts the given PP_TextRun to a WebTextRun, returning true on success.
 // False means the input was invalid.
 bool PPTextRunToWebTextRun(const PP_TextRun_Dev* run, WebTextRun* output) {
   scoped_refptr<StringVar> text_string(StringVar::FromPPVar(run->text));
   if (!text_string)
     return false;
   *output = WebTextRun(UTF8ToUTF16(text_string->value()),
-                       run->rtl, run->override_direction);
+                       PPBoolToBool(run->rtl),
+                       PPBoolToBool(run->override_direction));
   return true;
 }
 
 PP_Resource Create(PP_Module module_id,
                    const PP_FontDescription_Dev* description) {
   PluginModule* module = ResourceTracker::Get()->GetModule(module_id);
   if (!module)
     return 0;
 
   if (!IsPPFontDescriptionValid(*description))
     return 0;
 
   scoped_refptr<Font> font(new Font(module, *description));
   return font->GetReference();
 }
 
-bool IsFont(PP_Resource resource) {
-  return !!Resource::GetAs<Font>(resource).get();
+PP_Bool IsFont(PP_Resource resource) {
+  return BoolToPPBool(!!Resource::GetAs<Font>(resource).get());
 }
 
-bool Describe(PP_Resource font_id,
+PP_Bool Describe(PP_Resource font_id,
               PP_FontDescription_Dev* description,
               PP_FontMetrics_Dev* metrics) {
   scoped_refptr<Font> font(Resource::GetAs<Font>(font_id));
   if (!font.get())
-    return false;
-  return font->Describe(description, metrics);
+    return PP_FALSE;
+  return BoolToPPBool(font->Describe(description, metrics));
 }
 
-bool DrawTextAt(PP_Resource font_id,
+PP_Bool DrawTextAt(PP_Resource font_id,
                 PP_Resource image_data,
                 const PP_TextRun_Dev* text,
                 const PP_Point* position,
                 uint32_t color,
                 const PP_Rect* clip,
-                bool image_data_is_opaque) {
+                PP_Bool image_data_is_opaque) {
   scoped_refptr<Font> font(Resource::GetAs<Font>(font_id));
   if (!font.get())
-    return false;
-  return font->DrawTextAt(image_data, text, position, color, clip,
-                          image_data_is_opaque);
+    return PP_FALSE;
+  return BoolToPPBool(font->DrawTextAt(image_data, text, position, color, clip,
+                                       PPBoolToBool(image_data_is_opaque)));
 }
 
 int32_t MeasureText(PP_Resource font_id, const PP_TextRun_Dev* text) {
   scoped_refptr<Font> font(Resource::GetAs<Font>(font_id));
   if (!font.get())
     return -1;
   return font->MeasureText(text);
 }
 
 uint32_t CharacterOffsetForPixel(PP_Resource font_id,
@@ skipping 47 matching lines @@
 
   WebFontDescription web_desc = font_->fontDescription();
 
   // While converting the other way in PPFontDescToWebFontDesc we validated
   // that the enums can be casted.
   description->face = StringVar::StringToPPVar(module(),
                                                UTF16ToUTF8(web_desc.family));
   description->family = static_cast<PP_FontFamily_Dev>(web_desc.genericFamily);
   description->size = static_cast<uint32_t>(web_desc.size);
   description->weight = static_cast<PP_FontWeight_Dev>(web_desc.weight);
-  description->italic = web_desc.italic;
-  description->small_caps = web_desc.smallCaps;
+  description->italic = BoolToPPBool(web_desc.italic);
+  description->small_caps = BoolToPPBool(web_desc.smallCaps);
 
   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());
 
   return true;
 }
 
@@ skipping 57 matching lines @@
     return -1;
   if (char_offset >= run.text.length())
     return -1;
 
   WebFloatRect rect = font_->selectionRectForText(
       run, WebFloatPoint(0.0f, 0.0f), font_->height(), 0, char_offset);
   return static_cast<int>(rect.width);
 }
 
 }  // namespace pepper