Restructure the structs/unions involved in SRPC argument passing. This will...

src/trusted/plugin/npapi/scriptable_impl_npapi.cc

 /*
  * Copyright 2008 The Native Client Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can
  * be found in the LICENSE file.
  */
 
 
 // NPAPI Scriptable handle implementation.
 
 #include "native_client/src/trusted/plugin/npapi/scriptable_impl_npapi.h"
@@ skipping 75 matching lines @@
           if (!plugin::ScriptableImplNpapi::is_valid(scriptable_obj)) {
             return false;
           }
           // This function is called only when we are dealing with a
           // DescBasedHandle.
           plugin::PortableHandle* desc_handle = scriptable_obj->handle();
           inputs[i]->u.hval = desc_handle->desc();
         }
         break;
       case NACL_SRPC_ARG_TYPE_OBJECT:
-        if (!plugin::NPVariantToObject(&args[i], &inputs[i]->u.oval)) {
+        if (!plugin::NPVariantToObject(&args[i], &inputs[i]->arrays.oval)) {
           return false;
         }
         break;
       case NACL_SRPC_ARG_TYPE_INT:
         if (!plugin::NPVariantToScalar(&args[i], &inputs[i]->u.ival)) {
           return false;
         }
         break;
       case NACL_SRPC_ARG_TYPE_LONG:
         if (!plugin::NPVariantToScalar(&args[i], &inputs[i]->u.lval)) {
           return false;
         }
         break;
       case NACL_SRPC_ARG_TYPE_STRING:
-        if (!plugin::NPVariantToScalar(&args[i], &inputs[i]->u.sval.str)) {
+        if (!plugin::NPVariantToScalar(&args[i], &inputs[i]->arrays.str)) {
           return false;
         }
         break;
 
       case NACL_SRPC_ARG_TYPE_CHAR_ARRAY:
         /* SCOPE */ {
           if (!plugin::NPVariantToArray(&args[i],
                                         npp,
-                                        &inputs[i]->u.caval.count,
-                                        &inputs[i]->u.caval.carr)) {
+                                        &inputs[i]->u.count,
+                                        &inputs[i]->arrays.carr)) {
             return false;
           }
         }
         break;
 
       case NACL_SRPC_ARG_TYPE_DOUBLE_ARRAY:
         /* SCOPE */ {
           if (!plugin::NPVariantToArray(&args[i],
                                         npp,
-                                        &inputs[i]->u.daval.count,
-                                        &inputs[i]->u.daval.darr)) {
+                                        &inputs[i]->u.count,
+                                        &inputs[i]->arrays.darr)) {
             return false;
           }
         }
         break;
 
       case NACL_SRPC_ARG_TYPE_INT_ARRAY:
         /* SCOPE */ {
           if (!plugin::NPVariantToArray(&args[i],
                                         npp,
-                                        &inputs[i]->u.iaval.count,
-                                        &inputs[i]->u.iaval.iarr)) {
+                                        &inputs[i]->u.count,
+                                        &inputs[i]->arrays.iarr)) {
             return false;
           }
         }
         break;
 
       case NACL_SRPC_ARG_TYPE_LONG_ARRAY:
         /* SCOPE */ {
           if (!plugin::NPVariantToArray(&args[i],
                                         npp,
-                                        &inputs[i]->u.laval.count,
-                                        &inputs[i]->u.laval.larr)) {
+                                        &inputs[i]->u.count,
+                                        &inputs[i]->arrays.larr)) {
             return false;
           }
         }
         break;
 
       case NACL_SRPC_ARG_TYPE_INVALID:
       case NACL_SRPC_ARG_TYPE_VARIANT_ARRAY:
       default:
         return false;
     }
   }
 
   inputs_length = i;
 
   // Set the length values for the array-typed returns.
   for (i = 0; (i < NACL_SRPC_MAX_ARGS) && (NULL != outputs[i]); ++i) {
     switch (outputs[i]->tag) {
       case NACL_SRPC_ARG_TYPE_CHAR_ARRAY:
         if (!plugin::NPVariantToAllocatedArray(&args[i + inputs_length],
-                                               &outputs[i]->u.caval.count,
-                                               &outputs[i]->u.caval.carr)) {
+                                               &outputs[i]->u.count,
+                                               &outputs[i]->arrays.carr)) {
           return false;
         }
         break;
       case NACL_SRPC_ARG_TYPE_DOUBLE_ARRAY:
         if (!plugin::NPVariantToAllocatedArray(&args[i + inputs_length],
-                                               &outputs[i]->u.daval.count,
-                                               &outputs[i]->u.daval.darr)) {
+                                               &outputs[i]->u.count,
+                                               &outputs[i]->arrays.darr)) {
           return false;
         }
         break;
       case NACL_SRPC_ARG_TYPE_INT_ARRAY:
         if (!plugin::NPVariantToAllocatedArray(&args[i + inputs_length],
-                                               &outputs[i]->u.iaval.count,
-                                               &outputs[i]->u.iaval.iarr)) {
+                                               &outputs[i]->u.count,
+                                               &outputs[i]->arrays.iarr)) {
           return false;
         }
         break;
       case NACL_SRPC_ARG_TYPE_LONG_ARRAY:
         if (!plugin::NPVariantToAllocatedArray(&args[i + inputs_length],
-                                               &outputs[i]->u.laval.count,
-                                               &outputs[i]->u.laval.larr)) {
+                                               &outputs[i]->u.count,
+                                               &outputs[i]->arrays.larr)) {
           return false;
         }
         break;
       case NACL_SRPC_ARG_TYPE_BOOL:
       case NACL_SRPC_ARG_TYPE_DOUBLE:
       case NACL_SRPC_ARG_TYPE_HANDLE:
       case NACL_SRPC_ARG_TYPE_INT:
       case NACL_SRPC_ARG_TYPE_LONG:
       case NACL_SRPC_ARG_TYPE_STRING:
       case NACL_SRPC_ARG_TYPE_OBJECT:
@@ skipping 72 matching lines @@
       if (!plugin::ScalarToNPVariant(outs[i]->u.ival, retvalue)) {
         return false;
       }
       break;
     case NACL_SRPC_ARG_TYPE_LONG:
       if (!plugin::ScalarToNPVariant(outs[i]->u.lval, retvalue)) {
         return false;
       }
       break;
     case NACL_SRPC_ARG_TYPE_STRING:
-      if (!plugin::ScalarToNPVariant(outs[i]->u.sval.str, retvalue)) {
+      if (!plugin::ScalarToNPVariant(outs[i]->arrays.str, retvalue)) {
         return false;
       }
       break;
     case NACL_SRPC_ARG_TYPE_HANDLE:
       if (!plugin::NaClDescToNPVariant(portable_plugin,
                                        outs[i]->u.hval, retvalue)) {
         return false;
       }
       break;
     case NACL_SRPC_ARG_TYPE_CHAR_ARRAY:
-      if (!plugin::ArrayToNPVariant(outs[i]->u.caval.carr,
-                                    outs[i]->u.caval.count,
+      if (!plugin::ArrayToNPVariant(outs[i]->arrays.carr,
+                                    outs[i]->u.count,
                                     npp,
                                     retvalue)) {
         return false;
       }
       break;
     case NACL_SRPC_ARG_TYPE_DOUBLE_ARRAY:
-      if (!plugin::ArrayToNPVariant(outs[i]->u.daval.darr,
-                                    outs[i]->u.daval.count,
+      if (!plugin::ArrayToNPVariant(outs[i]->arrays.darr,
+                                    outs[i]->u.count,
                                     npp,
                                     retvalue)) {
         return false;
       }
       break;
     case NACL_SRPC_ARG_TYPE_INT_ARRAY:
-      if (!plugin::ArrayToNPVariant(outs[i]->u.iaval.iarr,
-                                    outs[i]->u.iaval.count,
+      if (!plugin::ArrayToNPVariant(outs[i]->arrays.iarr,
+                                    outs[i]->u.count,
                                     npp,
                                     retvalue)) {
         return false;
       }
       break;
     case NACL_SRPC_ARG_TYPE_LONG_ARRAY:
-      if (!plugin::ArrayToNPVariant(outs[i]->u.laval.larr,
-                                    outs[i]->u.laval.count,
+      if (!plugin::ArrayToNPVariant(outs[i]->arrays.larr,
+                                    outs[i]->u.count,
                                     npp,
                                     retvalue)) {
         return false;
       }
       break;
     case NACL_SRPC_ARG_TYPE_OBJECT:
       /* SCOPE */ {
         // Only predeclared plugin methods can return objects and they only
         // return a ScriptableHandle that is actually a ScriptableImplNpapi.
         // This is really ugly due to the multiple inheritance involved.
         // oval contains a ScriptableHandle.  And we need an NPObject.
         // So we have to cast down to ScriptableImplNpapi then back up.
         plugin::ScriptableHandle* handle =
-            reinterpret_cast<plugin::ScriptableHandle*>(outs[i]->u.oval);
+            reinterpret_cast<plugin::ScriptableHandle*>(outs[i]->arrays.oval);
         // This confirms that this this is indeed a valid ScriptableHandle
         // that was created by us. In theory, a predeclared method could
         // receive and return an opaque JavaScript object that is not
         // a ScriptableHandle. But we don't have methods like this at the
         // time. If one every creates such a method, this CHECK will fail
         // and remind the author to update this code to handle arbitrary
         // objects.
         CHECK(plugin::ScriptableHandle::is_valid(handle));
         plugin::ScriptableImplNpapi* handle_npapi =
             static_cast<plugin::ScriptableImplNpapi*>(handle);
@@ skipping 406 matching lines @@
   PLUGIN_PRINTF(("ScriptableImplNpapi::!ScriptableImplNpapi "
                  "(this=%p, handle=%p)\n",
                  static_cast<void*>(this), static_cast<void*>(handle())));
   handle()->Delete();
   set_handle(NULL);
   PLUGIN_PRINTF(("ScriptableImplNpapi::~ScriptableImplNpapi "
                  "(this=%p, return)\n", static_cast<void*>(this)));
 }
 
 }  // namespace plugin