Chrome side of converting enums to uppercase.

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 "base/logging.h"
 #include "base/scoped_ptr.h"
 #include "base/string_util.h"
 #include "third_party/ppapi/c/pp_var.h"
@@ skipping 19 matching lines @@
  public:
   TryCatch(PP_Var* exception) : exception_(exception) {
     WebBindings::pushExceptionHandler(&TryCatch::Catch, this);
   }
 
   ~TryCatch() {
     WebBindings::popExceptionHandler();
   }
 
   bool HasException() const {
-    return exception_ && exception_->type != PP_VarType_Void;
+    return exception_ && exception_->type != PP_VARTYPE_VOID;
   }
 
   void SetException(const char* message) {
     DCHECK(!HasException());
     if (exception_)
       *exception_ = VarFromUtf8(message, strlen(message));
   }
 
  private:
   static void Catch(void* self, const NPUTF8* message) {
@@ skipping 48 matching lines @@
   }
   NOTREACHED();
   return PP_MakeVoid();
 }
 
 // Returns a NPVariant that corresponds to the given PP_Var.  The contents of
 // the PP_Var will be copied unless the PP_Var corresponds to an object.
 NPVariant PPVarToNPVariant(PP_Var var) {
   NPVariant ret;
   switch (var.type) {
-    case PP_VarType_Void:
+    case PP_VARTYPE_VOID:
       VOID_TO_NPVARIANT(ret);
       break;
-    case PP_VarType_Null:
+    case PP_VARTYPE_NULL:
       NULL_TO_NPVARIANT(ret);
       break;
-    case PP_VarType_Bool:
+    case PP_VARTYPE_BOOL:
       BOOLEAN_TO_NPVARIANT(var.value.as_bool, ret);
       break;
-    case PP_VarType_Int32:
+    case PP_VARTYPE_INT32:
       INT32_TO_NPVARIANT(var.value.as_int, ret);
       break;
-    case PP_VarType_Double:
+    case PP_VARTYPE_DOUBLE:
       DOUBLE_TO_NPVARIANT(var.value.as_double, ret);
       break;
-    case PP_VarType_String: {
+    case PP_VARTYPE_STRING: {
       const std::string& value = GetStringUnchecked(var)->value();
       STRINGN_TO_NPVARIANT(base::strdup(value.c_str()), value.size(), ret);
       break;
     }
-    case PP_VarType_Object: {
+    case PP_VARTYPE_OBJECT: {
       NPObject* object = GetNPObjectUnchecked(var);
       OBJECT_TO_NPVARIANT(WebBindings::retainObject(object), ret);
       break;
     }
   }
   return ret;
 }
 
 // Returns a NPVariant that corresponds to the given PP_Var.  The contents of
 // the PP_Var will NOT be copied, so you need to ensure that the PP_Var remains
 // valid while the resultant NPVariant is in use.
 NPVariant PPVarToNPVariantNoCopy(PP_Var var) {
   NPVariant ret;
   switch (var.type) {
-    case PP_VarType_Void:
+    case PP_VARTYPE_VOID:
       VOID_TO_NPVARIANT(ret);
       break;
-    case PP_VarType_Null:
+    case PP_VARTYPE_NULL:
       NULL_TO_NPVARIANT(ret);
       break;
-    case PP_VarType_Bool:
+    case PP_VARTYPE_BOOL:
       BOOLEAN_TO_NPVARIANT(var.value.as_bool, ret);
       break;
-    case PP_VarType_Int32:
+    case PP_VARTYPE_INT32:
       INT32_TO_NPVARIANT(var.value.as_int, ret);
       break;
-    case PP_VarType_Double:
+    case PP_VARTYPE_DOUBLE:
       DOUBLE_TO_NPVARIANT(var.value.as_double, ret);
       break;
-    case PP_VarType_String: {
+    case PP_VARTYPE_STRING: {
       const std::string& value = GetStringUnchecked(var)->value();
       STRINGN_TO_NPVARIANT(value.c_str(), value.size(), ret);
       break;
     }
-    case PP_VarType_Object: {
+    case PP_VARTYPE_OBJECT: {
       OBJECT_TO_NPVARIANT(GetNPObjectUnchecked(var), ret);
       break;
     }
   }
   return ret;
 }
 
 // Returns a NPIdentifier that corresponds to the given PP_Var.  The contents
 // of the PP_Var will be copied.  Returns NULL if the given PP_Var is not a a
 // string or integer type.
 NPIdentifier PPVarToNPIdentifier(PP_Var var) {
   switch (var.type) {
-    case PP_VarType_String:
+    case PP_VARTYPE_STRING:
       return WebBindings::getStringIdentifier(
           GetStringUnchecked(var)->value().c_str());
-    case PP_VarType_Int32:
+    case PP_VARTYPE_INT32:
       return WebBindings::getIntIdentifier(var.value.as_int);
     default:
       return NULL;
   }
 }
 
 PP_Var NPIdentifierToPPVar(NPIdentifier id) {
   const NPUTF8* string_value = NULL;
   int32_t int_value = 0;
   bool is_string = false;
   WebBindings::extractIdentifierData(id, string_value, int_value, is_string);
   if (is_string)
     return VarFromUtf8(string_value, strlen(string_value));
 
   return PP_MakeInt32(int_value);
 }
 
 PP_Var NPIdentifierToPPVarString(NPIdentifier id) {
   PP_Var var = NPIdentifierToPPVar(id);
-  if (var.type == PP_VarType_String)
+  if (var.type == PP_VARTYPE_STRING)
     return var;
-  DCHECK(var.type == PP_VarType_Int32);
+  DCHECK(var.type == PP_VARTYPE_INT32);
   const std::string& str = IntToString(var.value.as_int);
   return VarFromUtf8(str.data(), str.size());
 }
 
 void ThrowException(NPObject* object, PP_Var exception) {
   String* str = GetString(exception);
   if (str)
     WebBindings::setException(object, str->value().c_str());
 }
 
@@ skipping 26 matching lines @@
 bool WrapperClass_HasMethod(NPObject* object, NPIdentifier method_name) {
   WrapperObject* wrapper = ToWrapper(object);
 
   PP_Var method_name_var = NPIdentifierToPPVarString(method_name);
   PP_Var exception = PP_MakeVoid();
   bool rv = wrapper->ppp_class->HasMethod(wrapper->ppp_class_data,
                                           method_name_var,
                                           &exception);
   Release(method_name_var);
 
-  if (exception.type != PP_VarType_Void) {
+  if (exception.type != PP_VARTYPE_VOID) {
     ThrowException(object, exception);
     Release(exception);
     return false;
   }
   return rv;
 }
 
 bool WrapperClass_Invoke(NPObject* object, NPIdentifier method_name,
                          const NPVariant* argv, uint32_t argc,
                          NPVariant* result) {
   WrapperObject* wrapper = ToWrapper(object);
 
   scoped_array<PP_Var> args;
   if (argc) {
     args.reset(new PP_Var[argc]);
     for (uint32_t i = 0; i < argc; ++i)
       args[i] = NPVariantToPPVar(&argv[i]);
   }
   PP_Var method_name_var = NPIdentifierToPPVarString(method_name);
   PP_Var exception = PP_MakeVoid();
   PP_Var result_var = wrapper->ppp_class->Call(wrapper->ppp_class_data,
                                                method_name_var, argc,
                                                args.get(), &exception);
   Release(method_name_var);
   for (uint32_t i = 0; i < argc; ++i)
     Release(args[i]);
 
   bool rv;
-  if (exception.type == PP_VarType_Void) {
+  if (exception.type == PP_VARTYPE_VOID) {
     rv = true;
     *result = PPVarToNPVariant(result_var);
   } else {
     rv = false;
     ThrowException(object, exception);
     Release(exception);
   }
   Release(result_var);
   return rv;
 }
 
 bool WrapperClass_InvokeDefault(NPObject* object, const NPVariant* argv,
                                 uint32_t argc, NPVariant* result) {
   WrapperObject* wrapper = ToWrapper(object);
 
   scoped_array<PP_Var> args;
   if (argc) {
     args.reset(new PP_Var[argc]);
     for (uint32_t i = 0; i < argc; ++i)
       args[i] = NPVariantToPPVar(&argv[i]);
   }
   PP_Var exception = PP_MakeVoid();
   PP_Var result_var = wrapper->ppp_class->Call(wrapper->ppp_class_data,
                                                PP_MakeVoid(), argc, args.get(),
                                                &exception);
   for (uint32_t i = 0; i < argc; ++i)
     Release(args[i]);
 
   bool rv;
-  if (exception.type == PP_VarType_Void) {
+  if (exception.type == PP_VARTYPE_VOID) {
     rv = true;
     *result = PPVarToNPVariant(result_var);
   } else {
     rv = false;
     ThrowException(object, exception);
     Release(exception);
   }
   Release(result_var);
   return rv;
 }
 
 bool WrapperClass_HasProperty(NPObject* object, NPIdentifier property_name) {
   WrapperObject* wrapper = ToWrapper(object);
 
   PP_Var property_name_var = NPIdentifierToPPVar(property_name);
   PP_Var exception = PP_MakeVoid();
   bool rv = wrapper->ppp_class->HasProperty(wrapper->ppp_class_data,
                                             property_name_var,
                                             &exception);
   Release(property_name_var);
 
-  if (exception.type != PP_VarType_Void) {
+  if (exception.type != PP_VARTYPE_VOID) {
     ThrowException(object, exception);
     Release(exception);
     return false;
   }
   return rv;
 }
 
 bool WrapperClass_GetProperty(NPObject* object, NPIdentifier property_name,
                               NPVariant* result) {
   WrapperObject* wrapper = ToWrapper(object);
 
   PP_Var property_name_var = NPIdentifierToPPVar(property_name);
   PP_Var exception = PP_MakeVoid();
   PP_Var result_var = wrapper->ppp_class->GetProperty(wrapper->ppp_class_data,
                                                       property_name_var,
                                                       &exception);
   Release(property_name_var);
 
   bool rv;
-  if (exception.type == PP_VarType_Void) {
+  if (exception.type == PP_VARTYPE_VOID) {
     rv = true;
     *result = PPVarToNPVariant(result_var);
   } else {
     rv = false;
     ThrowException(object, exception);
     Release(exception);
   }
   Release(result_var);
   return rv;
 }
 
 bool WrapperClass_SetProperty(NPObject* object, NPIdentifier property_name,
                               const NPVariant* value) {
   WrapperObject* wrapper = ToWrapper(object);
 
   PP_Var property_name_var = NPIdentifierToPPVar(property_name);
   PP_Var value_var = NPVariantToPPVar(value);
   PP_Var exception = PP_MakeVoid();
   wrapper->ppp_class->SetProperty(wrapper->ppp_class_data, property_name_var,
                                   value_var, &exception);
   Release(value_var);
   Release(property_name_var);
 
-  if (exception.type != PP_VarType_Void) {
+  if (exception.type != PP_VARTYPE_VOID) {
     ThrowException(object, exception);
     Release(exception);
     return false;
   }
   return true;
 }
 
 bool WrapperClass_RemoveProperty(NPObject* object, NPIdentifier property_name) {
   WrapperObject* wrapper = ToWrapper(object);
 
   PP_Var property_name_var = NPIdentifierToPPVar(property_name);
   PP_Var exception = PP_MakeVoid();
   wrapper->ppp_class->RemoveProperty(wrapper->ppp_class_data, property_name_var,
                                      &exception);
   Release(property_name_var);
 
-  if (exception.type != PP_VarType_Void) {
+  if (exception.type != PP_VARTYPE_VOID) {
     ThrowException(object, exception);
     Release(exception);
     return false;
   }
   return true;
 }
 
 bool WrapperClass_Enumerate(NPObject* object, NPIdentifier** values,
                             uint32_t* count) {
   WrapperObject* wrapper = ToWrapper(object);
 
   uint32_t property_count = 0;
   PP_Var* properties = NULL;
   PP_Var exception = PP_MakeVoid();
   wrapper->ppp_class->GetAllPropertyNames(wrapper->ppp_class_data,
                                           &property_count,
                                           &properties,
                                           &exception);
 
   bool rv;
-  if (exception.type == PP_VarType_Void) {
+  if (exception.type == PP_VARTYPE_VOID) {
     rv = true;
     if (property_count == 0) {
       *values = NULL;
       *count = 0;
     } else {
       *values = static_cast<NPIdentifier*>(
           malloc(sizeof(NPIdentifier) * property_count));
       *count = property_count;
       for (uint32_t i = 0; i < property_count; ++i)
         (*values)[i] = PPVarToNPIdentifier(properties[i]);
@@ skipping 22 matching lines @@
   }
 
   PP_Var exception = PP_MakeVoid();
   PP_Var result_var = wrapper->ppp_class->Construct(wrapper->ppp_class_data,
                                                     argc, args.get(),
                                                     &exception);
   for (uint32_t i = 0; i < argc; ++i)
     Release(args[i]);
 
   bool rv;
-  if (exception.type == PP_VarType_Void) {
+  if (exception.type == PP_VARTYPE_VOID) {
     rv = true;
     *result = PPVarToNPVariant(result_var);
   } else {
     rv = false;
     ThrowException(object, exception);
     Release(exception);
   }
   Release(result_var);
   return rv;
 }
@@ skipping 11 matching lines @@
   WrapperClass_SetProperty,
   WrapperClass_RemoveProperty,
   WrapperClass_Enumerate,
   WrapperClass_Construct
 };
 
 // ---------------------------------------------------------------------------
 // PPB_Var methods
 
 void AddRef(PP_Var var) {
-  if (var.type == PP_VarType_String) {
+  if (var.type == PP_VARTYPE_STRING) {
     GetStringUnchecked(var)->AddRef();
-  } else if (var.type == PP_VarType_Object) {
+  } else if (var.type == PP_VARTYPE_OBJECT) {
     // TODO(darin): Add thread safety check
     WebBindings::retainObject(GetNPObjectUnchecked(var));
   }
 }
 
 void Release(PP_Var var) {
-  if (var.type == PP_VarType_String) {
+  if (var.type == PP_VARTYPE_STRING) {
     GetStringUnchecked(var)->Release();
-  } else if (var.type == PP_VarType_Object) {
+  } else if (var.type == PP_VARTYPE_OBJECT) {
     // TODO(darin): Add thread safety check
     WebBindings::releaseObject(GetNPObjectUnchecked(var));
   }
 }
 
 PP_Var VarFromUtf8(const char* data, uint32_t len) {
   String* str = new String(data, len);
   str->AddRef();  // This is for the caller, we return w/ a refcount of 1.
   PP_Var ret;
-  ret.type = PP_VarType_String;
+  ret.type = PP_VARTYPE_STRING;
   ret.value.as_id = reinterpret_cast<intptr_t>(str);
   return ret;
 }
 
 const char* VarToUtf8(PP_Var var, uint32_t* len) {
-  if (var.type != PP_VarType_String) {
+  if (var.type != PP_VARTYPE_STRING) {
     *len = 0;
     return NULL;
   }
   const std::string& str = GetStringUnchecked(var)->value();
   *len = static_cast<uint32_t>(str.size());
   if (str.empty())
     return "";  // Don't return NULL on success.
   return str.data();
 }
 
@@ skipping 169 matching lines @@
   if (try_catch.HasException())
     return PP_MakeVoid();
 
   NPObject* object = GetNPObject(var);
   if (!object) {
     try_catch.SetException(kInvalidObjectException);
     return PP_MakeVoid();
   }
 
   NPIdentifier identifier;
-  if (method_name.type == PP_VarType_Void) {
+  if (method_name.type == PP_VARTYPE_VOID) {
     identifier = NULL;
-  } else if (method_name.type == PP_VarType_String) {
+  } else if (method_name.type == PP_VARTYPE_STRING) {
     // Specifically allow only string functions to be called.
     identifier = PPVarToNPIdentifier(method_name);
     if (!identifier) {
       try_catch.SetException(kInvalidPropertyException);
       return PP_MakeVoid();
     }
   } else {
     try_catch.SetException(kInvalidPropertyException);
     return PP_MakeVoid();
   }
@@ skipping 107 matching lines @@
 };
 
 }  // namespace
 
 const PPB_Var* GetVarInterface() {
   return &var_interface;
 }
 
 PP_Var NPObjectToPPVar(NPObject* object) {
   PP_Var ret;
-  ret.type = PP_VarType_Object;
+  ret.type = PP_VARTYPE_OBJECT;
   ret.value.as_id = reinterpret_cast<intptr_t>(object);
   WebBindings::retainObject(object);
   return ret;
 }
 
 NPObject* GetNPObject(PP_Var var) {
-  if (var.type != PP_VarType_Object)
+  if (var.type != PP_VARTYPE_OBJECT)
     return NULL;
   return GetNPObjectUnchecked(var);
 }
 
 PP_Var StringToPPVar(const std::string& str) {
   DCHECK(IsStringUTF8(str));
   return VarFromUtf8(str.data(), str.size());
 }
 
 String* GetString(PP_Var var) {
-  if (var.type != PP_VarType_String)
+  if (var.type != PP_VARTYPE_STRING)
     return NULL;
   return GetStringUnchecked(var);
 }
 
 }  // namespace pepper