Update the PPAPI DEPS revision. This change included parameter profile chang...

src/shared/ppapi_proxy/object_serialize.cc

 /*
  * Copyright 2010 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.
  */
 
 #include "native_client/src/shared/ppapi_proxy/object_serialize.h"
 
 #include <string.h>
 #include <limits>
@@ skipping 194 matching lines @@
       default:
         return false;
     }
     offset += element_size;
   }
   return true;
 }
 
 bool DeserializeString(char* p,
                        PP_Var* var,
-                       uint32_t* element_size) {
+                       uint32_t* element_size,
+                       NaClSrpcChannel* channel) {
   SerializedString* ss = reinterpret_cast<SerializedString*>(p);
   uint32_t string_length = ss->fixed.u.string_length;
   if (AddWouldOverflow(string_length, kStringRoundBase - 1)) {
     // Rounding to the next 8 would overflow.
     return false;
   }
   uint32_t rounded_length = RoundedStringBytes(string_length);
   if (0 == string_length) {
     // Zero-length string.  Rely on what the PPB_Var does.
-    *var = VarInterface()->VarFromUtf8(ss->string_bytes, 0);
+    *var = VarInterface()->VarFromUtf8(LookupModuleIdForSrpcChannel(channel),
+                                       ss->string_bytes,
+                                       0);
   } else {
     // We need to copy the string payload using memory allocated by
     // NPN_MemAlloc.
     void* copy = CoreInterface()->MemAlloc(string_length + 1);
     if (NULL == copy) {
       // Memory allocation failed.
       return false;
     } else {
       memmove(copy, ss->string_bytes, string_length);
     }
-    *var = VarInterface()->VarFromUtf8(reinterpret_cast<const char*>(copy),
+    *var = VarInterface()->VarFromUtf8(LookupModuleIdForSrpcChannel(channel),
+                                       reinterpret_cast<const char*>(copy),
                                        string_length);
   }
   // Compute the "element_size", or offset in the serialized form from
   // the serialized string that we just read.
   if (AddWouldOverflow(rounded_length, sizeof(SerializedFixed))) {
     return false;
   }
   *element_size = sizeof(SerializedFixed) + rounded_length;
   return true;
 }
@@ skipping 27 matching lines @@
         vars[i].value.as_int = s->u.int32_value;
         element_size = sizeof(SerializedFixed);
         break;
       case PP_VARTYPE_DOUBLE: {
         SerializedDouble* sd = reinterpret_cast<SerializedDouble*>(p);
         vars[i].value.as_double = sd->double_value;
         element_size = sizeof(SerializedDouble);
         break;
       }
       case PP_VARTYPE_STRING:
-        if (!DeserializeString(p, &vars[i], &element_size)) {
+        if (!DeserializeString(p, &vars[i], &element_size, channel)) {
           return false;
         }
         break;
       case PP_VARTYPE_OBJECT: {
         SerializedObject* so = reinterpret_cast<SerializedObject*>(p);
         ObjectCapability capability = so->capability;
         vars[i] = ObjectProxy::New(capability, channel);
         element_size = sizeof(SerializedObject);
         break;
       }
@@ skipping 76 matching lines @@
     return false;
   }
   // Read the serialized PP_Vars into the allocated memory.
   if (!DeserializePpVar(channel, bytes, length, vars, argc)) {
     return false;
   }
   return true;
 }
 
 }  // namespace ppapi_proxy