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

webkit/glue/plugins/pepper_var.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_var.h"
 
 #include <limits>
 
 #include "base/logging.h"
 #include "base/scoped_ptr.h"
 #include "base/string_util.h"
 #include "ppapi/c/dev/ppb_var_deprecated.h"
 #include "ppapi/c/ppb_var.h"
 #include "ppapi/c/pp_var.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebBindings.h"
+#include "webkit/glue/plugins/pepper_common.h"
 #include "webkit/glue/plugins/pepper_plugin_instance.h"
 #include "webkit/glue/plugins/pepper_plugin_module.h"
 #include "webkit/glue/plugins/pepper_plugin_object.h"
 #include "v8/include/v8.h"
 
 using WebKit::WebBindings;
 
 namespace pepper {
 
 namespace {
@@ skipping 264 matching lines @@
     else
       result = PP_MakeInt32(0);
   } else if (new_type == PP_VARTYPE_DOUBLE && result.type == PP_VARTYPE_INT32) {
     result = PP_MakeDouble(result.value.as_int);
   }
 
   Var::PluginReleasePPVar(object);
   return result;
 }
 
+PP_Var BoolToPPVar(bool value) {
+  return PP_MakeBool(BoolToPPBool(value));
+}
+
 void DefineProperty(struct PP_Var object,
                     struct PP_ObjectProperty property,
                     PP_Var* exception) {
   PP_Var params[] = {
     object, property.name,
-    PP_MakeBool(!!(property.modifiers & PP_OBJECTPROPERTY_MODIFIER_HASVALUE)),
+    BoolToPPVar(!!(property.modifiers & PP_OBJECTPROPERTY_MODIFIER_HASVALUE)),
     property.value,
-    PP_MakeBool(property.getter.type == PP_VARTYPE_OBJECT),
+    BoolToPPVar(property.getter.type == PP_VARTYPE_OBJECT),
     property.getter,
-    PP_MakeBool(property.setter.type == PP_VARTYPE_OBJECT),
+    BoolToPPVar(property.setter.type == PP_VARTYPE_OBJECT),
     property.setter,
-    PP_MakeBool(!!(property.modifiers & PP_OBJECTPROPERTY_MODIFIER_READONLY)),
-    PP_MakeBool(!!(property.modifiers & PP_OBJECTPROPERTY_MODIFIER_DONTDELETE)),
-    PP_MakeBool(!!(property.modifiers & PP_OBJECTPROPERTY_MODIFIER_DONTENUM))
+    BoolToPPVar(!!(property.modifiers & PP_OBJECTPROPERTY_MODIFIER_READONLY)),
+    BoolToPPVar(!!(property.modifiers & PP_OBJECTPROPERTY_MODIFIER_DONTDELETE)),
+    BoolToPPVar(!!(property.modifiers & PP_OBJECTPROPERTY_MODIFIER_DONTENUM))
   };
 
   RunJSFunction(object,
       "(function(o, name,"
       "          has_value,  value,"
       "          has_getter, getter,"
       "          has_setter, setter,"
       "          modifier_readonly, modifier_dontdelete, modifier_dontenum) {"
       "  prop = { 'enumerable':   !modifier_dontenum,"
       "           'configurable': !modifier_dontdelete };"
       "  if (has_value && !modifier_readonly) prop.writable = true;"
       "  if (has_value)                       prop.value    = value;"
       "  if (has_getter)                      prop.get      = getter;"
       "  if (has_setter)                      prop.set      = setter;"
       "  return Object.defineProperty(o, name, prop); })",
       params, sizeof(params) / sizeof(PP_Var), exception);
 }
 
-bool HasProperty(PP_Var var,
-                 PP_Var name,
-                 PP_Var* exception) {
+PP_Bool HasProperty(PP_Var var,
+                    PP_Var name,
+                    PP_Var* exception) {
   ObjectAccessorWithIdentifierTryCatch accessor(var, name, exception);
   if (accessor.has_exception())
-    return false;
-  return WebBindings::hasProperty(NULL, accessor.object()->np_object(),
-                                  accessor.identifier());
+    return PP_FALSE;
+  return BoolToPPBool(WebBindings::hasProperty(NULL,
+                                               accessor.object()->np_object(),
+                                               accessor.identifier()));
+}
+
+bool HasPropertyDeprecated(PP_Var var,
+                           PP_Var name,
+                           PP_Var* exception) {
+  return PPBoolToBool(HasProperty(var, name, exception));
 }
 
 bool HasMethodDeprecated(PP_Var var,
                          PP_Var name,
                          PP_Var* exception) {
   ObjectAccessorWithIdentifierTryCatch accessor(var, name, exception);
   if (accessor.has_exception())
     return false;
   return WebBindings::hasMethod(NULL, accessor.object()->np_object(),
                                 accessor.identifier());
@@ skipping 61 matching lines @@
   NPVariant variant;
   if (!PPVarToNPVariantNoCopy(value, &variant)) {
     accessor.SetException(kInvalidValueException);
     return;
   }
   if (!WebBindings::setProperty(NULL, accessor.object()->np_object(),
                                 accessor.identifier(), &variant))
     accessor.SetException(kUnableToSetPropertyException);
 }
 
-bool DeleteProperty(PP_Var var,
-                    PP_Var name,
-                    PP_Var* exception) {
+PP_Bool DeleteProperty(PP_Var var,
+                       PP_Var name,
+                       PP_Var* exception) {
   ObjectAccessorWithIdentifierTryCatch accessor(var, name, exception);
   if (accessor.has_exception())
-    return false;
+    return PP_FALSE;
 
-  return WebBindings::removeProperty(NULL, accessor.object()->np_object(),
-                                     accessor.identifier());
+  return BoolToPPBool(
+      WebBindings::removeProperty(NULL,
+                                  accessor.object()->np_object(),
+                                  accessor.identifier()));
 }
 
 void DeletePropertyDeprecated(PP_Var var,
                               PP_Var name,
                               PP_Var* exception) {
   ObjectAccessorWithIdentifierTryCatch accessor(var, name, exception);
   if (accessor.has_exception())
     return;
 
   if (!WebBindings::removeProperty(NULL, accessor.object()->np_object(),
                                    accessor.identifier()))
     accessor.SetException(kUnableToRemovePropertyException);
 }
 
-bool IsCallable(struct PP_Var object) {
+PP_Bool IsCallable(struct PP_Var object) {
   PP_Var result = RunJSFunction(object,
       "(function() { return typeof(this) == 'function' })", NULL, 0, NULL);
-  return result.type == PP_VARTYPE_BOOL && result.value.as_bool;
+  if (result.type == PP_VARTYPE_BOOL)
+    return result.value.as_bool;
+  return PP_FALSE;
 }
 
 struct PP_Var Call(struct PP_Var object,
                    struct PP_Var this_object,
                    uint32_t argc,
                    struct PP_Var* argv,
                    struct PP_Var* exception) {
   ObjectAccessorTryCatch accessor(object, exception);
   if (accessor.has_exception())
     return PP_MakeUndefined();
@@ skipping 132 matching lines @@
   if (!module)
     return PP_MakeNull();
   return PluginObject::Create(module, ppp_class, ppp_class_data);
 }
 
 const PPB_Var_Deprecated var_deprecated_interface = {
   &Var::PluginAddRefPPVar,
   &Var::PluginReleasePPVar,
   &VarFromUtf8,
   &VarToUtf8,
-  &HasProperty,
+  &HasPropertyDeprecated,
   &HasMethodDeprecated,
   &GetProperty,
   &EnumerateProperties,
   &SetPropertyDeprecated,
   &DeletePropertyDeprecated,
   &CallDeprecated,
   &Construct,
   &IsInstanceOfDeprecated,
   &CreateObjectDeprecated
 };
@@ skipping 26 matching lines @@
 }
 
 // static
 PP_Var Var::NPVariantToPPVar(PluginModule* module, const NPVariant* variant) {
   switch (variant->type) {
     case NPVariantType_Void:
       return PP_MakeUndefined();
     case NPVariantType_Null:
       return PP_MakeNull();
     case NPVariantType_Bool:
-      return PP_MakeBool(NPVARIANT_TO_BOOLEAN(*variant));
+      return BoolToPPVar(NPVARIANT_TO_BOOLEAN(*variant));
     case NPVariantType_Int32:
       return PP_MakeInt32(NPVARIANT_TO_INT32(*variant));
     case NPVariantType_Double:
       return PP_MakeDouble(NPVARIANT_TO_DOUBLE(*variant));
     case NPVariantType_String:
       return StringVar::StringToPPVar(
           module,
           NPVARIANT_TO_STRING(*variant).UTF8Characters,
           NPVARIANT_TO_STRING(*variant).UTF8Length);
     case NPVariantType_Object:
@@ skipping 170 matching lines @@
       *exception_ = PP_MakeInt32(1);
   }
 }
 
 // static
 void TryCatch::Catch(void* self, const char* message) {
   static_cast<TryCatch*>(self)->SetException(message);
 }
 
 }  // namespace pepper