Unrevert 58354, reland PPAPI with the instance test disabled.

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_number_conversions.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"
 
 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) {
-    WebBindings::pushExceptionHandler(&TryCatch::Catch, this);
-  }
-
-  ~TryCatch() {
-    WebBindings::popExceptionHandler();
-  }
-
-  bool HasException() const {
-    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) {
-    static_cast<TryCatch*>(self)->SetException(message);
-  }
-
-  // May be null if the consumer isn't interesting in catching exceptions.
-  PP_Var* exception_;
-};
-
 const char kInvalidObjectException[] = "Error: Invalid object";
 const char kInvalidPropertyException[] = "Error: Invalid property";
 const char kUnableToGetPropertyException[] = "Error: Unable to get property";
 const char kUnableToSetPropertyException[] = "Error: Unable to set property";
 const char kUnableToRemovePropertyException[] =
     "Error: Unable to remove property";
 const char kUnableToGetAllPropertiesException[] =
     "Error: Unable to get all properties";
 const char kUnableToCallMethodException[] = "Error: Unable to call method";
 const char kUnableToConstructException[] = "Error: Unable to construct";
 
 // ---------------------------------------------------------------------------
 // Utilities
 
 String* GetStringUnchecked(PP_Var var) {
   return reinterpret_cast<String*>(var.value.as_id);
 }
 
 NPObject* GetNPObjectUnchecked(PP_Var var) {
   return reinterpret_cast<NPObject*>(var.value.as_id);
 }
 
-// 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));
-    case NPVariantType_Int32:
-      return PP_MakeInt32(NPVARIANT_TO_INT32(*variant));
-    case NPVariantType_Double:
-      return PP_MakeDouble(NPVARIANT_TO_DOUBLE(*variant));
-    case NPVariantType_String:
-      return VarFromUtf8(NPVARIANT_TO_STRING(*variant).UTF8Characters,
-                         NPVARIANT_TO_STRING(*variant).UTF8Length);
-    case NPVariantType_Object:
-      return NPObjectToPPVar(NPVARIANT_TO_OBJECT(*variant));
-  }
-  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:
       VOID_TO_NPVARIANT(ret);
       break;
     case PP_VARTYPE_NULL:
       NULL_TO_NPVARIANT(ret);
@@ skipping 723 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;
 }
 
+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));
+    case NPVariantType_Int32:
+      return PP_MakeInt32(NPVARIANT_TO_INT32(*variant));
+    case NPVariantType_Double:
+      return PP_MakeDouble(NPVARIANT_TO_DOUBLE(*variant));
+    case NPVariantType_String:
+      return VarFromUtf8(NPVARIANT_TO_STRING(*variant).UTF8Characters,
+                         NPVARIANT_TO_STRING(*variant).UTF8Length);
+    case NPVariantType_Object:
+      return NPObjectToPPVar(NPVARIANT_TO_OBJECT(*variant));
+  }
+  NOTREACHED();
+  return PP_MakeVoid();
+}
+
+
 NPObject* GetNPObject(PP_Var var) {
   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)
     return NULL;
   return GetStringUnchecked(var);
 }
 
+TryCatch::TryCatch(PP_Var* exception) : exception_(exception) {
+  WebBindings::pushExceptionHandler(&TryCatch::Catch, this);
+}
+
+TryCatch::~TryCatch() {
+  WebBindings::popExceptionHandler();
+}
+
+bool TryCatch::HasException() const {
+  return exception_ && exception_->type != PP_VARTYPE_VOID;
+}
+
+void TryCatch::SetException(const char* message) {
+  DCHECK(!HasException());
+  if (exception_)
+    *exception_ = VarFromUtf8(message, strlen(message));
+}
+
+// static
+void TryCatch::Catch(void* self, const char* message) {
+  static_cast<TryCatch*>(self)->SetException(message);
+}
+
+
 }  // namespace pepper