Use the new callback tracker and delete the old one

webkit/plugins/ppapi/ppb_transport_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_transport_impl.h"
 
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/socket/socket.h"
 #include "ppapi/c/dev/ppb_transport_dev.h"
 #include "ppapi/c/pp_completion_callback.h"
 #include "ppapi/c/pp_errors.h"
+#include "ppapi/shared_impl/callback_tracker.h"
+#include "ppapi/shared_impl/ppapi_globals.h"
 #include "ppapi/shared_impl/var.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebElement.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebPluginContainer.h"
 #include "webkit/plugins/ppapi/common.h"
 #include "webkit/plugins/ppapi/plugin_module.h"
 #include "webkit/plugins/ppapi/ppapi_plugin_instance.h"
 #include "webkit/plugins/ppapi/resource_helper.h"
 
 using ppapi::StringVar;
 using ppapi::thunk::PPB_Transport_API;
+using ppapi::TrackedCallback;
 using webkit_glue::P2PTransport;
 
 namespace webkit {
 namespace ppapi {
 
 namespace {
 
 const char kUdpProtocolName[] = "udp";
 const char kTcpProtocolName[] = "tcp";
 
@@ skipping 214 matching lines @@
           GetFrameForResource(this), name_, protocol, config_, this)) {
     return PP_ERROR_FAILED;
   }
 
   started_ = true;
 
   PluginModule* plugin_module = ResourceHelper::GetPluginModule(this);
   if (!plugin_module)
     return PP_ERROR_FAILED;
 
-  connect_callback_ = new TrackedCompletionCallback(
-      plugin_module->GetCallbackTracker(), pp_resource(), callback);
+  connect_callback_ = new TrackedCallback(this, callback);
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t PPB_Transport_Impl::GetNextAddress(PP_Var* address,
                                            PP_CompletionCallback callback) {
   if (!callback.func)
     return PP_ERROR_BLOCKS_MAIN_THREAD;
   if (!p2p_transport_.get())
     return PP_ERROR_FAILED;
 
-  if (next_address_callback_.get() && !next_address_callback_->completed())
+  if (TrackedCallback::IsPending(next_address_callback_))
     return PP_ERROR_INPROGRESS;
 
   PluginModule* plugin_module = ResourceHelper::GetPluginModule(this);
   if (!plugin_module)
     return PP_ERROR_FAILED;
 
   if (!local_candidates_.empty()) {
     *address = StringVar::StringToPPVar(local_candidates_.front());
     local_candidates_.pop_front();
     return PP_OK;
   }
 
-  next_address_callback_ = new TrackedCompletionCallback(
-      plugin_module->GetCallbackTracker(), pp_resource(), callback);
+  next_address_callback_ = new TrackedCallback(this, callback);
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t PPB_Transport_Impl::ReceiveRemoteAddress(PP_Var address) {
   if (!p2p_transport_.get())
     return PP_ERROR_FAILED;
 
   StringVar* address_str = StringVar::FromPPVar(address);
   if (!address_str)
     return PP_ERROR_BADARGUMENT;
 
   return p2p_transport_->AddRemoteCandidate(address_str->value()) ?
       PP_OK : PP_ERROR_FAILED;
 }
 
 int32_t PPB_Transport_Impl::Recv(void* data, uint32_t len,
                                  PP_CompletionCallback callback) {
   if (!callback.func)
     return PP_ERROR_BLOCKS_MAIN_THREAD;
   if (!p2p_transport_.get())
     return PP_ERROR_FAILED;
 
-  if (recv_callback_.get() && !recv_callback_->completed())
+  if (TrackedCallback::IsPending(recv_callback_))
     return PP_ERROR_INPROGRESS;
 
   net::Socket* channel = p2p_transport_->GetChannel();
   if (!channel)
     return PP_ERROR_FAILED;
 
   PluginModule* plugin_module = ResourceHelper::GetPluginModule(this);
   if (!plugin_module)
     return PP_ERROR_FAILED;
 
   scoped_refptr<net::IOBuffer> buffer =
       new net::WrappedIOBuffer(static_cast<const char*>(data));
   int result = MapNetError(
       channel->Read(buffer, len, base::Bind(&PPB_Transport_Impl::OnRead,
                                             base::Unretained(this))));
-  if (result == PP_OK_COMPLETIONPENDING) {
-    recv_callback_ = new TrackedCompletionCallback(
-        plugin_module->GetCallbackTracker(), pp_resource(), callback);
-  }
+  if (result == PP_OK_COMPLETIONPENDING)
+    recv_callback_ = new TrackedCallback(this, callback);
 
   return result;
 }
 
 int32_t PPB_Transport_Impl::Send(const void* data, uint32_t len,
                                  PP_CompletionCallback callback) {
   if (!callback.func)
     return PP_ERROR_BLOCKS_MAIN_THREAD;
   if (!p2p_transport_.get())
     return PP_ERROR_FAILED;
 
-  if (send_callback_.get() && !send_callback_->completed())
+  if (TrackedCallback::IsPending(send_callback_))
     return PP_ERROR_INPROGRESS;
 
   net::Socket* channel = p2p_transport_->GetChannel();
   if (!channel)
     return PP_ERROR_FAILED;
 
   PluginModule* plugin_module = ResourceHelper::GetPluginModule(this);
   if (!plugin_module)
     return PP_ERROR_FAILED;
 
   scoped_refptr<net::IOBuffer> buffer =
       new net::WrappedIOBuffer(static_cast<const char*>(data));
   int result = MapNetError(
       channel->Write(buffer, len, base::Bind(&PPB_Transport_Impl::OnWritten,
                                              base::Unretained(this))));
-  if (result == PP_OK_COMPLETIONPENDING) {
-    send_callback_ = new TrackedCompletionCallback(
-        plugin_module->GetCallbackTracker(), pp_resource(), callback);
-  }
+  if (result == PP_OK_COMPLETIONPENDING)
+    send_callback_ = new TrackedCallback(this, callback);
 
   return result;
 }
 
 int32_t PPB_Transport_Impl::Close() {
   if (!p2p_transport_.get())
     return PP_ERROR_FAILED;
 
   p2p_transport_.reset();
 
-  PluginModule* plugin_module = ResourceHelper::GetPluginModule(this);
-  if (plugin_module)
-    plugin_module->GetCallbackTracker()->AbortAll();
+  ::ppapi::PpapiGlobals::Get()->GetCallbackTrackerForInstance(
+      pp_instance())->PostAbortForResource(pp_resource());
   return PP_OK;
 }
 
 void PPB_Transport_Impl::OnCandidateReady(const std::string& address) {
   // Store the candidate first before calling the callback.
   local_candidates_.push_back(address);
 
-  if (next_address_callback_.get() && !next_address_callback_->completed()) {
-    scoped_refptr<TrackedCompletionCallback> callback;
-    callback.swap(next_address_callback_);
-    callback->Run(PP_OK);
-  }
+  if (TrackedCallback::IsPending(next_address_callback_))
+    TrackedCallback::ClearAndRun(&next_address_callback_, PP_OK);
 }
 
 void PPB_Transport_Impl::OnStateChange(webkit_glue::P2PTransport::State state) {
   writable_ = (state | webkit_glue::P2PTransport::STATE_WRITABLE) != 0;
-  if (writable_ && connect_callback_.get() && !connect_callback_->completed()) {
-    scoped_refptr<TrackedCompletionCallback> callback;
-    callback.swap(connect_callback_);
-    callback->Run(PP_OK);
-  }
+  if (writable_ && TrackedCallback::IsPending(connect_callback_))
+    TrackedCallback::ClearAndRun(&connect_callback_, PP_OK);
 }
 
 void PPB_Transport_Impl::OnError(int error) {
   writable_ = false;
-  if (connect_callback_.get() && !connect_callback_->completed()) {
-    scoped_refptr<TrackedCompletionCallback> callback;
-    callback.swap(connect_callback_);
-    callback->Run(PP_ERROR_FAILED);
-  }
+  if (TrackedCallback::IsPending(connect_callback_))
+    TrackedCallback::ClearAndRun(&connect_callback_, PP_ERROR_FAILED);
 }
 
 void PPB_Transport_Impl::OnRead(int result) {
-  DCHECK(recv_callback_.get() && !recv_callback_->completed());
-
-  scoped_refptr<TrackedCompletionCallback> callback;
-  callback.swap(recv_callback_);
-  callback->Run(MapNetError(result));
+  DCHECK(TrackedCallback::IsPending(recv_callback_));
+  TrackedCallback::ClearAndRun(&recv_callback_, MapNetError(result));
 }
 
 void PPB_Transport_Impl::OnWritten(int result) {
-  DCHECK(send_callback_.get() && !send_callback_->completed());
-
-  scoped_refptr<TrackedCompletionCallback> callback;
-  callback.swap(send_callback_);
-  callback->Run(MapNetError(result));
+  DCHECK(TrackedCallback::IsPending(send_callback_));
+  TrackedCallback::ClearAndRun(&send_callback_, MapNetError(result));
 }
 
 }  // namespace ppapi
 }  // namespace webkit