Remove PP_Module from parameters for PPB_Var.VarFromUtf8.

ppapi/native_client/src/shared/ppapi_proxy/object_serialize.cc

 /*
  * Copyright (c) 2011 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 "native_client/src/shared/ppapi_proxy/object_serialize.h"
 
 #include <limits>
 #include <stdio.h>
@@ skipping 309 matching lines @@
   }
   return expected_element_size;
 }
 
 
 //
 // This should be invoked only if DeserializePpVarSize succeeds, i.e.,
 // there are enough bytes at p.
 //
 bool DeserializeString(char* p,
-                       PP_Var* var,
-                       NaClSrpcChannel* channel) {
+                       PP_Var* var) {
   SerializedString* ss = reinterpret_cast<SerializedString*>(p);
   uint32_t string_length = ss->fixed.u.string_length;
   // VarFromUtf8 creates a buffer of size string_length using the browser-side
   // memory allocation function, and copies string_length bytes from
   // ss->string_bytes in to that buffer.  The ref count of the returned var is
   // 1.
-  *var = PPBVarInterface()->VarFromUtf8(LookupModuleIdForSrpcChannel(channel),
-                                        ss->string_bytes,
+  *var = PPBVarInterface()->VarFromUtf8(ss->string_bytes,
                                         string_length);
   return true;
 }
 
-bool DeserializePpVar(NaClSrpcChannel* channel,
-                      char* bytes,
+bool DeserializePpVar(char* bytes,
                       uint32_t length,
                       PP_Var* vars,
                       uint32_t argc) {
   char* p = bytes;
 
   for (uint32_t i = 0; i < argc; ++i) {
     PP_VarType element_type;
     uint32_t element_size = DeserializePpVarSize(p, length, &element_type);
     if (std::numeric_limits<uint32_t>::max() == element_size) {
       return false;
@@ skipping 10 matching lines @@
         break;
       case PP_VARTYPE_INT32:
         vars[i].value.as_int = s->u.int32_value;
         break;
       case PP_VARTYPE_DOUBLE: {
         SerializedDouble* sd = reinterpret_cast<SerializedDouble*>(p);
         vars[i].value.as_double = sd->double_value;
         break;
       }
       case PP_VARTYPE_STRING:
-        if (!DeserializeString(p, &vars[i], channel)) {
+        if (!DeserializeString(p, &vars[i])) {
           return false;
         }
         break;
       case PP_VARTYPE_OBJECT:
       case PP_VARTYPE_ARRAY:
       case PP_VARTYPE_DICTIONARY:
       case PP_VARTYPE_ARRAY_BUFFER:
         NACL_NOTREACHED();
       default:
         return false;
@@ skipping 51 matching lines @@
   // Serialize the vars.
   if (!SerializePpVar(vars, argc, bytes, tmp_length)) {
     delete[] bytes;
     return NULL;
   }
   // Return success.
   *length = tmp_length;
   return bytes;
 }
 
-bool DeserializeTo(NaClSrpcChannel* channel,
-                   char* bytes,
+bool DeserializeTo(char* bytes,
                    uint32_t length,
                    uint32_t argc,
                    PP_Var* vars) {
   // Deserializing a zero-length vector is trivially done.
   if (0 == argc) {
     return true;
   }
   // Otherwise, there must be some input bytes to get from.
   if (NULL == bytes || 0 == length) {
     return false;
   }
   // And there has to be a valid address to deserialize to.
   if (NULL == vars) {
     return false;
   }
   // Read the serialized PP_Vars into the allocated memory.
-  if (!DeserializePpVar(channel, bytes, length, vars, argc)) {
+  if (!DeserializePpVar(bytes, length, vars, argc)) {
     return false;
   }
   return true;
 }
 
 }  // namespace ppapi_proxy