Remove PP_Module from parameters for PPB_Var.VarFromUtf8.

webkit/plugins/ppapi/ppb_websocket_impl.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/ppb_websocket_impl.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
@@ skipping 66 matching lines @@
 PPB_WebSocket_Impl::PPB_WebSocket_Impl(PP_Instance instance)
     : Resource(instance),
       state_(PP_WEBSOCKETREADYSTATE_INVALID_DEV),
       error_was_received_(false),
       receive_callback_var_(NULL),
       wait_for_receive_(false),
       close_code_(0),
       close_was_clean_(PP_FALSE),
       buffered_amount_(0),
       buffered_amount_after_close_(0) {
-  empty_string_ = new StringVar(
-      PpapiGlobals::Get()->GetModuleForInstance(instance), "", 0);
+  empty_string_ = new StringVar("", 0);
 }
 
 PPB_WebSocket_Impl::~PPB_WebSocket_Impl() {
   if (websocket_.get())
     websocket_->disconnect();
 
   // Clean up received and unread messages
   VarTracker* var_tracker = PpapiGlobals::Get()->GetVarTracker();
   while (!received_messages_.empty()) {
     PP_Var var = received_messages_.front();
@@ skipping 27 matching lines @@
     return PP_ERROR_INPROGRESS;
   if (state_ != PP_WEBSOCKETREADYSTATE_INVALID_DEV)
     return PP_ERROR_INPROGRESS;
   state_ = PP_WEBSOCKETREADYSTATE_CLOSED_DEV;
 
   // Validate url and convert it to WebURL.
   scoped_refptr<StringVar> url_string = StringVar::FromPPVar(url);
   if (!url_string)
     return PP_ERROR_BADARGUMENT;
   GURL gurl(url_string->value());
-  url_ = new StringVar(
-      PpapiGlobals::Get()->GetModuleForInstance(pp_instance()), gurl.spec());
+  url_ = new StringVar(gurl.spec());
   if (!gurl.is_valid())
     return PP_ERROR_BADARGUMENT;
   if (!gurl.SchemeIs("ws") && !gurl.SchemeIs("wss"))
     return PP_ERROR_BADARGUMENT;
   if (gurl.has_ref())
     return PP_ERROR_BADARGUMENT;
   if (!net::IsPortAllowedByDefault(gurl.IntPort()))
     return PP_ERROR_BADARGUMENT;
   WebURL web_url(gurl);
 
@@ skipping 198 matching lines @@
     return empty_string_->GetPPVar();
   return extensions_->GetPPVar();
 }
 
 PP_Var PPB_WebSocket_Impl::GetProtocol() {
   // Check mandatory interfaces.
   if (!websocket_.get())
     return empty_string_->GetPPVar();
 
   std::string protocol = websocket_->subprotocol().utf8();
-  return StringVar::StringToPPVar(
-      PpapiGlobals::Get()->GetModuleForInstance(pp_instance()), protocol);
+  return StringVar::StringToPPVar(protocol);
 }
 
 PP_WebSocketReadyState_Dev PPB_WebSocket_Impl::GetReadyState() {
   return state_;
 }
 
 PP_Var PPB_WebSocket_Impl::GetURL() {
   if (!url_)
     return empty_string_->GetPPVar();
   return url_->GetPPVar();
 }
 
 void PPB_WebSocket_Impl::didConnect() {
   DCHECK_EQ(PP_WEBSOCKETREADYSTATE_CONNECTING_DEV, state_);
   state_ = PP_WEBSOCKETREADYSTATE_OPEN_DEV;
   PP_RunAndClearCompletionCallback(&connect_callback_, PP_OK);
 }
 
 void PPB_WebSocket_Impl::didReceiveMessage(const WebString& message) {
   // Dispose packets after receiving an error or in invalid state.
   if (error_was_received_ || !InValidStateToReceive(state_))
     return;
 
   // Append received data to queue.
   std::string string = message.utf8();
-  PP_Var var = StringVar::StringToPPVar(
-      PpapiGlobals::Get()->GetModuleForInstance(pp_instance()), string);
+  PP_Var var = StringVar::StringToPPVar(string);
   received_messages_.push(var);
 
   if (!wait_for_receive_)
     return;
 
   PP_RunAndClearCompletionCallback(&receive_callback_, DoReceive());
 }
 
 void PPB_WebSocket_Impl::didReceiveBinaryData(const WebData& binaryData) {
   // Dispose packets after receiving an error or in invalid state.
@@ skipping 33 matching lines @@
   state_ = PP_WEBSOCKETREADYSTATE_CLOSING_DEV;
 }
 
 void PPB_WebSocket_Impl::didClose(unsigned long unhandled_buffered_amount,
                                   ClosingHandshakeCompletionStatus status,
                                   unsigned short code,
                                   const WebString& reason) {
   // Store code and reason.
   close_code_ = code;
   std::string reason_string = reason.utf8();
-  close_reason_ = new StringVar(
-      PpapiGlobals::Get()->GetModuleForInstance(pp_instance()), reason_string);
+  close_reason_ = new StringVar(reason_string);
 
   // Set close_was_clean_.
   bool was_clean =
       state_ == PP_WEBSOCKETREADYSTATE_CLOSING_DEV &&
       !unhandled_buffered_amount &&
       status == WebSocketClient::ClosingHandshakeComplete;
   close_was_clean_ = was_clean ? PP_TRUE : PP_FALSE;
 
   // Update buffered_amount_.
   buffered_amount_ = unhandled_buffered_amount;
@@ skipping 20 matching lines @@
 
   *receive_callback_var_ = received_messages_.front();
   received_messages_.pop();
   receive_callback_var_ = NULL;
   wait_for_receive_ = false;
   return PP_OK;
 }
 
 }  // namespace ppapi
 }  // namespace webkit