Convert ppapi/shared to use TrackedCallback.

ppapi/shared_impl/ppb_file_io_shared.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 "ppapi/shared_impl/ppb_file_io_shared.h"
 
 #include <string.h>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/shared_impl/file_type_conversion.h"
 #include "ppapi/shared_impl/time_conversion.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/ppb_file_ref_api.h"
 
 namespace ppapi {
 
 using thunk::EnterResourceNoLock;
 using thunk::PPB_FileIO_API;
 using thunk::PPB_FileRef_API;
 
 PPB_FileIO_Shared::CallbackEntry::CallbackEntry()
     : read_buffer(NULL),
       info(NULL) {
-  callback.func = NULL;
-  callback.user_data = NULL;
 }
 
 PPB_FileIO_Shared::CallbackEntry::CallbackEntry(const CallbackEntry& entry)
     : callback(entry.callback),
       read_buffer(entry.read_buffer),
       info(entry.info) {
 }
 
 PPB_FileIO_Shared::CallbackEntry::~CallbackEntry() {
 }
@@ skipping 13 matching lines @@
 }
 
 PPB_FileIO_Shared::~PPB_FileIO_Shared() {
   // The callbacks list should have been cleared by LastPluginRefWasDeleted.
   DCHECK(callbacks_.empty());
 }
 
 void PPB_FileIO_Shared::LastPluginRefWasDeleted() {
   // Abort all pending callbacks. Do this by posting a task to avoid reentering
   // the plugin's Release() call that probably deleted this object.
-  for (size_t i = 0; i < callbacks_.size(); i++) {
-    MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
-        callbacks_[i].callback.func, callbacks_[i].callback.user_data,
-        static_cast<int32_t>(PP_ERROR_ABORTED)));
-  }
+  for (size_t i = 0; i < callbacks_.size(); i++)

[viettrungluu, 2012/01/03 22:43:46]

I suppose you could also use PostAbortForResource()? (Slightly slower, but
slightly cleaner?)

[brettw, 2012/01/04 00:27:29]

Actually I can just delete this code, it's already done by the resource tracker.

+    callbacks_[i].callback->PostAbort();
   callbacks_.erase(callbacks_.begin(), callbacks_.end());
 }
 
 thunk::PPB_FileIO_API* PPB_FileIO_Shared::AsPPB_FileIO_API() {
   return this;
 }
 
 int32_t PPB_FileIO_Shared::Open(PP_Resource file_ref,
                                 int32_t open_flags,
                                 PP_CompletionCallback callback) {
@@ skipping 133 matching lines @@
 
 void PPB_FileIO_Shared::RegisterCallback(OperationType op,
                                          PP_CompletionCallback callback,
                                          char* read_buffer,
                                          PP_FileInfo* info) {
   DCHECK(callback.func);
   DCHECK(pending_op_ == OPERATION_NONE ||
          (pending_op_ != OPERATION_EXCLUSIVE && pending_op_ == op));
 
   CallbackEntry entry;
-  entry.callback = callback;
+  entry.callback = new TrackedCallback(this, callback);
   entry.read_buffer = read_buffer;
   entry.info = info;
   callbacks_.push_back(entry);
 
   pending_op_ = op;
 }
 
 void PPB_FileIO_Shared::RunAndRemoveFirstPendingCallback(int32_t result) {
   DCHECK(!callbacks_.empty());
 
   CallbackEntry front = callbacks_.front();
   callbacks_.pop_front();
   if (callbacks_.empty())
     pending_op_ = OPERATION_NONE;
 
-  PP_RunCompletionCallback(&front.callback, result);
+  front.callback->Run(result);
 }
 
 }  // namespace ppapi