Support using TrackedCallbacks as hints to determine the handling thread of resource reply messages

ppapi/proxy/udp_socket_resource_base.cc

 // Copyright 2013 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 "ppapi/proxy/udp_socket_resource_base.h"
 
 #include <algorithm>
 #include <cstring>
 
 #include "base/logging.h"
@@ skipping 73 matching lines @@
       NOTREACHED();
       return PP_ERROR_BADARGUMENT;
     }
   }
 
   Call<PpapiPluginMsg_UDPSocket_SetOptionReply>(
       BROWSER,
       PpapiHostMsg_UDPSocket_SetOption(name, option_data),
       base::Bind(&UDPSocketResourceBase::OnPluginMsgSetOptionReply,
                  base::Unretained(this),
-                 callback));
+                 callback),
+      callback);
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t UDPSocketResourceBase::BindImpl(
     const PP_NetAddress_Private* addr,
     scoped_refptr<TrackedCallback> callback) {
   if (!addr)
     return PP_ERROR_BADARGUMENT;
   if (bound_ || closed_)
     return PP_ERROR_FAILED;
   if (TrackedCallback::IsPending(bind_callback_))
     return PP_ERROR_INPROGRESS;
 
   bind_callback_ = callback;
 
   // Send the request, the browser will call us back via BindReply.
   Call<PpapiPluginMsg_UDPSocket_BindReply>(
       BROWSER,
       PpapiHostMsg_UDPSocket_Bind(*addr),
       base::Bind(&UDPSocketResourceBase::OnPluginMsgBindReply,
-                 base::Unretained(this)));
+                 base::Unretained(this)),
+      callback);
   return PP_OK_COMPLETIONPENDING;
 }
 
 PP_Bool UDPSocketResourceBase::GetBoundAddressImpl(
     PP_NetAddress_Private* addr) {
   if (!addr || !bound_ || closed_)
     return PP_FALSE;
 
   *addr = bound_addr_;
   return PP_TRUE;
@@ skipping 13 matching lines @@
 
   read_buffer_ = buffer;
   bytes_to_read_ = std::min(num_bytes, kMaxReadSize);
   recvfrom_callback_ = callback;
 
   // Send the request, the browser will call us back via RecvFromReply.
   Call<PpapiPluginMsg_UDPSocket_RecvFromReply>(
       BROWSER,
       PpapiHostMsg_UDPSocket_RecvFrom(bytes_to_read_),
       base::Bind(&UDPSocketResourceBase::OnPluginMsgRecvFromReply,
-                 base::Unretained(this), addr));
+                 base::Unretained(this), addr),
+      callback);
   return PP_OK_COMPLETIONPENDING;
 }
 
 PP_Bool UDPSocketResourceBase::GetRecvFromAddressImpl(
     PP_NetAddress_Private* addr) {
   if (!addr)
     return PP_FALSE;
   *addr = recvfrom_addr_;
   return PP_TRUE;
 }
@@ skipping 13 matching lines @@
   if (num_bytes > kMaxWriteSize)
     num_bytes = kMaxWriteSize;
 
   sendto_callback_ = callback;
 
   // Send the request, the browser will call us back via SendToReply.
   Call<PpapiPluginMsg_UDPSocket_SendToReply>(
       BROWSER,
       PpapiHostMsg_UDPSocket_SendTo(std::string(buffer, num_bytes), *addr),
       base::Bind(&UDPSocketResourceBase::OnPluginMsgSendToReply,
-                 base::Unretained(this)));
+                 base::Unretained(this)),
+      callback);
   return PP_OK_COMPLETIONPENDING;
 }
 
 void UDPSocketResourceBase::CloseImpl() {
   if(closed_)
     return;
 
   bound_ = false;
   closed_ = true;
 
@@ skipping 88 matching lines @@
 }
 
 void UDPSocketResourceBase::RunCallback(scoped_refptr<TrackedCallback> callback,
                                         int32_t pp_result) {
   callback->Run(ConvertNetworkAPIErrorForCompatibility(pp_result,
                                                        private_api_));
 }
 
 }  // namespace proxy
 }  // namespace ppapi