Remove PP_Module from parameters for PPB_Var.VarFromUtf8.

webkit/plugins/ppapi/npapi_glue.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 "webkit/plugins/ppapi/npapi_glue.h"
 
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/string_util.h"
 #include "webkit/plugins/ppapi/host_globals.h"
@@ skipping 77 matching lines @@
     case NPVariantType_Null:
       return PP_MakeNull();
     case NPVariantType_Bool:
       return PP_MakeBool(PP_FromBool(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 StringVar::StringToPPVar(
-          instance->module()->pp_module(),
           NPVARIANT_TO_STRING(*variant).UTF8Characters,
           NPVARIANT_TO_STRING(*variant).UTF8Length);
     case NPVariantType_Object:
       return NPObjectToPPVar(instance, NPVARIANT_TO_OBJECT(*variant));
   }
   NOTREACHED();
   return PP_MakeUndefined();
 }
 
 NPIdentifier PPVarToNPIdentifier(PP_Var var) {
   switch (var.type) {
     case PP_VARTYPE_STRING: {
       StringVar* string = StringVar::FromPPVar(var);
       if (!string)
         return NULL;
       return WebBindings::getStringIdentifier(string->value().c_str());
     }
     case PP_VARTYPE_INT32:
       return WebBindings::getIntIdentifier(var.value.as_int);
     default:
       return NULL;
   }
 }
 
-PP_Var NPIdentifierToPPVar(PP_Module module, NPIdentifier id) {
+PP_Var NPIdentifierToPPVar(NPIdentifier id) {
   const NPUTF8* string_value = NULL;
   int32_t int_value = 0;
   bool is_string = false;
   WebBindings::extractIdentifierData(id, string_value, int_value, is_string);
   if (is_string)
-    return StringVar::StringToPPVar(module, string_value);
+    return StringVar::StringToPPVar(string_value);
 
   return PP_MakeInt32(int_value);
 }
 
 PP_Var NPObjectToPPVar(PluginInstance* instance, NPObject* object) {
   DCHECK(object);
   scoped_refptr<NPObjectVar> object_var(
       HostGlobals::Get()->host_var_tracker()->NPObjectVarForNPObject(
           instance->pp_instance(), object));
   if (!object_var) {  // No object for this module yet, make a new one.
-    object_var = new NPObjectVar(instance->module()->pp_module(),
-                                 instance->pp_instance(), object);
+    object_var = new NPObjectVar(instance->pp_instance(), object);
   }
   return object_var->GetPPVar();
 }
 
 // PPResultAndExceptionToNPResult ----------------------------------------------
 
 PPResultAndExceptionToNPResult::PPResultAndExceptionToNPResult(
     NPObject* object_var,
     NPVariant* np_result)
     : object_var_(object_var),
@@ skipping 103 matching lines @@
 
 // NPObjectAccessorWithIdentifier ----------------------------------------------
 
 NPObjectAccessorWithIdentifier::NPObjectAccessorWithIdentifier(
     NPObject* object,
     NPIdentifier identifier,
     bool allow_integer_identifier)
     : object_(PluginObject::FromNPObject(object)),
       identifier_(PP_MakeUndefined()) {
   if (object_) {
-    identifier_ = NPIdentifierToPPVar(
-        object_->instance()->module()->pp_module(), identifier);
+    identifier_ = NPIdentifierToPPVar(identifier);
     if (identifier_.type == PP_VARTYPE_INT32 && !allow_integer_identifier)
       identifier_.type = PP_VARTYPE_UNDEFINED;  // Mark it invalid.
   }
 }
 
 NPObjectAccessorWithIdentifier::~NPObjectAccessorWithIdentifier() {
   PpapiGlobals::Get()->GetVarTracker()->ReleaseVar(identifier_);
 }
 
 // TryCatch --------------------------------------------------------------------
 
-TryCatch::TryCatch(PP_Module module, PP_Var* exception)
-    : pp_module_(module),
-      has_exception_(exception && exception->type != PP_VARTYPE_UNDEFINED),
+TryCatch::TryCatch(PP_Var* exception)
+    : has_exception_(exception && exception->type != PP_VARTYPE_UNDEFINED),
       exception_(exception) {
   WebBindings::pushExceptionHandler(&TryCatch::Catch, this);
 }
 
 TryCatch::~TryCatch() {
   WebBindings::popExceptionHandler();
 }
 
 void TryCatch::SetException(const char* message) {
-  if (!pp_module_) {
-    // Don't have a module to make the string.
-    SetInvalidObjectException();
-    return;
-  }
-
   if (!has_exception()) {
     has_exception_ = true;
     if (exception_) {
-      *exception_ = ::ppapi::StringVar::StringToPPVar(pp_module_,
-                                                      message, strlen(message));
+      *exception_ = ::ppapi::StringVar::StringToPPVar(message, strlen(message));
     }
   }
 }
 
-void TryCatch::SetInvalidObjectException() {
-  if (!has_exception()) {
-    has_exception_ = true;
-    // TODO(brettw) bug 54504: Have a global singleton string that can hold
-    // a generic error message.
-    if (exception_)
-      *exception_ = PP_MakeInt32(1);
-  }
-}
-
 // static
 void TryCatch::Catch(void* self, const char* message) {
   static_cast<TryCatch*>(self)->SetException(message);
 }
 
 }  // namespace ppapi
 }  // namespace webkit