Chromium side of supporting property enumeration, memory allocation, querying...

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"
 #include "third_party/ppapi/c/ppb_var.h"
 #include "third_party/ppapi/c/ppp_class.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebBindings.h"
 #include "webkit/glue/plugins/pepper_string.h"
 #include "v8/include/v8.h"
 
-// Uncomment to enable catching JS exceptions
-// #define HAVE_WEBBINDINGS_EXCEPTION_HANDLER 1
-
 using WebKit::WebBindings;
 
 namespace pepper {
 
 namespace {
 
 void Release(PP_Var var);
 PP_Var VarFromUtf8(const char* data, uint32_t len);
 
 // ---------------------------------------------------------------------------
 // Exceptions
 
 class TryCatch {
  public:
   TryCatch(PP_Var* exception) : exception_(exception) {
-#ifdef HAVE_WEBBINDINGS_EXCEPTION_HANDLER
     WebBindings::pushExceptionHandler(&TryCatch::Catch, this);
-#endif
   }
 
   ~TryCatch() {
-#ifdef HAVE_WEBBINDINGS_EXCEPTION_HANDLER
     WebBindings::popExceptionHandler();
-#endif
   }
 
   bool HasException() const {
     return exception_ && exception_->type != PP_VarType_Void;
   }
 
   void SetException(const char* message) {
     DCHECK(!HasException());
     if (exception_)
       *exception_ = VarFromUtf8(message, strlen(message));
@@ skipping 29 matching lines @@
 String* GetString(PP_Var var) {
   if (var.type != PP_VarType_String)
     return NULL;
   return GetStringUnchecked(var);
 }
 
 NPObject* GetNPObjectUnchecked(PP_Var var) {
   return reinterpret_cast<NPObject*>(var.value.as_id);
 }
 
-NPObject* GetNPObject(PP_Var var) {
-  if (var.type != PP_VarType_Object)
-    return NULL;
-  return GetNPObjectUnchecked(var);
-}
-
 // Returns a PP_Var that corresponds to the given NPVariant.  The contents of
 // the NPVariant will be copied unless the NPVariant corresponds to an object.
 PP_Var NPVariantToPPVar(const NPVariant* variant) {
   switch (variant->type) {
     case NPVariantType_Void:
       return PP_MakeVoid();
     case NPVariantType_Null:
       return PP_MakeNull();
     case NPVariantType_Bool:
       return PP_MakeBool(NPVARIANT_TO_BOOLEAN(*variant));
@@ skipping 301 matching lines @@
   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) {
-  // TODO(darin): Implement this method!
-  WebBindings::setException(object, kUnableToGetAllPropertiesException);
-  return false;
+  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) {
+    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]);
+    }
+  } else {
+    rv = false;
+    ThrowException(object, exception);
+    Release(exception);
+  }
+
+  for (uint32_t i = 0; i < property_count; ++i)
+    Release(properties[i]);
+  free(properties);
+  return rv;
 }
 
 bool WrapperClass_Construct(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)
@@ skipping 151 matching lines @@
 
   PP_Var ret = NPVariantToPPVar(&result);
   WebBindings::releaseVariantValue(&result);
   return ret;
 }
 
 void GetAllPropertyNames(PP_Var var,
                          uint32_t* property_count,
                          PP_Var** properties,
                          PP_Var* exception) {
+  *properties = NULL;
+  *property_count = 0;
+
   TryCatch try_catch(exception);
   if (try_catch.HasException())
     return;
 
-  // TODO(darin): Implement this method!
-  try_catch.SetException(kUnableToGetAllPropertiesException);
+  NPObject* object = GetNPObject(var);
+  if (!object) {
+    try_catch.SetException(kInvalidObjectException);
+    return;
+  }
+
+  NPIdentifier* identifiers = NULL;
+  uint32_t count = 0;
+  if (!WebBindings::enumerate(NULL, object, &identifiers, &count)) {
+    if (!try_catch.HasException())
+      try_catch.SetException(kUnableToGetAllPropertiesException);
+    return;
+  }
+
+  if (count == 0)
+    return;
+
+  *property_count = count;
+  *properties = static_cast<PP_Var*>(malloc(sizeof(PP_Var) * count));
+  for (uint32_t i = 0; i < count; ++i)
+    (*properties)[i] = NPIdentifierToPPVar(identifiers[i]);
+  free(identifiers);
 }
 
 void SetProperty(PP_Var var,
                  PP_Var name,
                  PP_Var value,
                  PP_Var* exception) {
   TryCatch try_catch(exception);
   if (try_catch.HasException())
     return;
 
@@ skipping 182 matching lines @@
 }
 
 PP_Var NPObjectToPPVar(NPObject* object) {
   PP_Var ret;
   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)
+    return NULL;
+  return GetNPObjectUnchecked(var);
+}
+
 }  // namespace pepper