Revert 58328 - Pull new PPAPI, reland 58319 and 58321....

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