Use the new callback tracker and delete the old one

webkit/plugins/ppapi/ppb_url_loader_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_url_loader_impl.h"
 
 #include "base/logging.h"
 #include "net/base/net_errors.h"
 #include "ppapi/c/pp_completion_callback.h"
 #include "ppapi/c/pp_errors.h"
@@ skipping 18 matching lines @@
 #include "webkit/plugins/ppapi/ppapi_plugin_instance.h"
 #include "webkit/plugins/ppapi/ppb_url_request_info_impl.h"
 #include "webkit/plugins/ppapi/ppb_url_response_info_impl.h"
 #include "webkit/plugins/ppapi/resource_helper.h"
 
 using appcache::WebApplicationCacheHostImpl;
 using ppapi::Resource;
 using ppapi::thunk::EnterResourceNoLock;
 using ppapi::thunk::PPB_URLLoader_API;
 using ppapi::thunk::PPB_URLRequestInfo_API;
+using ppapi::TrackedCallback;
 using WebKit::WebFrame;
 using WebKit::WebString;
 using WebKit::WebURL;
 using WebKit::WebURLError;
 using WebKit::WebURLLoader;
 using WebKit::WebURLLoaderOptions;
 using WebKit::WebURLRequest;
 using WebKit::WebURLResponse;
 
 #ifdef _MSC_VER
@@ skipping 261 matching lines @@
                                         int data_length,
                                         int encoded_data_length) {
   // Note that |loader| will be NULL for document loads.
   bytes_received_ += data_length;
   UpdateStatus();
 
   buffer_.insert(buffer_.end(), data, data + data_length);
   if (user_buffer_) {
     RunCallback(FillUserBuffer());
   } else {
-    DCHECK(!pending_callback_.get() || pending_callback_->completed());
+    DCHECK(!TrackedCallback::IsPending(pending_callback_));
   }
 
   // To avoid letting the network stack download an entire stream all at once,
   // defer loading when we have enough buffer.
   // Check the buffer size after potentially moving some to the user buffer.
   DCHECK(request_data_.prefetch_buffer_lower_threshold <
          request_data_.prefetch_buffer_upper_threshold);
   if (!is_streaming_to_file_ &&
       !is_asynchronous_load_suspended_ &&
       (buffer_.size() >= static_cast<size_t>(
@@ skipping 36 matching lines @@
 
   // TODO(brettw) bug 96770: We need a way to set the defers loading flag on
   // main document loads (when the loader_ is null).
 }
 
 void PPB_URLLoader_Impl::FinishLoading(int32_t done_status) {
   done_status_ = done_status;
   // If the client hasn't called any function that takes a callback since
   // the initial call to Open, or called ReadResponseBody and got a
   // synchronous return, then the callback will be NULL.
-  if (pending_callback_.get() && !pending_callback_->completed())
+  if (TrackedCallback::IsPending(pending_callback_))
     RunCallback(done_status_);
 }
 
 int32_t PPB_URLLoader_Impl::ValidateCallback(PP_CompletionCallback callback) {
   // We only support non-blocking calls.
   if (!callback.func)
     return PP_ERROR_BLOCKS_MAIN_THREAD;
 
-  if (pending_callback_.get() && !pending_callback_->completed())
+  if (TrackedCallback::IsPending(pending_callback_))
     return PP_ERROR_INPROGRESS;
 
   return PP_OK;
 }
 
 void PPB_URLLoader_Impl::RegisterCallback(PP_CompletionCallback callback) {
   DCHECK(callback.func);
-  DCHECK(!pending_callback_.get() || pending_callback_->completed());
+  DCHECK(!TrackedCallback::IsPending(pending_callback_));
 
   PluginModule* plugin_module = ResourceHelper::GetPluginModule(this);
   if (!plugin_module)
     return;
 
-  pending_callback_ = new TrackedCompletionCallback(
-      plugin_module->GetCallbackTracker(), pp_resource(), callback);
+  pending_callback_ = new TrackedCallback(this, callback);
 }
 
 void PPB_URLLoader_Impl::RunCallback(int32_t result) {
   // This may be null only when this is a main document loader.
   if (!pending_callback_.get()) {
     CHECK(main_document_loader_);
     return;
   }
-
-  scoped_refptr<TrackedCompletionCallback> callback;
-  callback.swap(pending_callback_);
-  callback->Run(result);  // Will complete abortively if necessary.
+  TrackedCallback::ClearAndRun(&pending_callback_, result);
 }
 
 size_t PPB_URLLoader_Impl::FillUserBuffer() {
   DCHECK(user_buffer_);
   DCHECK(user_buffer_size_);
 
   size_t bytes_to_copy = std::min(buffer_.size(), user_buffer_size_);
   std::copy(buffer_.begin(), buffer_.begin() + bytes_to_copy, user_buffer_);
   buffer_.erase(buffer_.begin(), buffer_.begin() + bytes_to_copy);
 
@@ skipping 38 matching lines @@
 bool PPB_URLLoader_Impl::RecordDownloadProgress() const {
   return request_data_.record_download_progress;
 }
 
 bool PPB_URLLoader_Impl::RecordUploadProgress() const {
   return request_data_.record_upload_progress;
 }
 
 }  // namespace ppapi
 }  // namespace webkit