Use the new callback tracker and delete the old one

ppapi/shared_impl/tracked_callback.h

 // 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.
 
 #ifndef PPAPI_SHARED_IMPL_TRACKED_CALLBACK_H_
 #define PPAPI_SHARED_IMPL_TRACKED_CALLBACK_H_
 
 #include <map>
 #include <set>
 
@@ skipping 45 matching lines @@
                   const PP_CompletionCallback& callback);
 
   // These run the callback in an abortive manner, or post a task to do so (but
   // immediately marking the callback as to be aborted).
   void Abort();
   void PostAbort();
 
   // Run the callback with the given result. If the callback had previously been
   // marked as to be aborted (by |PostAbort()|), |result| will be ignored and
   // the callback will be run with result |PP_ERROR_ABORTED|.
+  //
+  // See also ClearAndRun().
   void Run(int32_t result);
 
   // Returns the ID of the resource which "owns" the callback, or 0 if the
   // callback is not associated with any resource.
   PP_Resource resource_id() const { return resource_id_; }
 
   // Returns true if the callback was completed (possibly aborted).
   bool completed() const { return completed_; }
 
   // Returns true if the callback was or should be aborted; this will be the
   // case whenever |Abort()| or |PostAbort()| is called before a non-abortive
   // completion.
   bool aborted() const { return aborted_; }
 
+  // Helper to determine if the given callback is set and not yet completed.
+  // The normal pattern is to use a scoped_refptr to hold a callback. This
+  // function tells you if the operation is currently in progress by checking
+  // both the null-ness of the scoped_refptr, as well as the completion state
+  // of the callback (which may still be out-standing via a PostAbort).
+  static bool IsPending(const scoped_refptr<TrackedCallback>& callback);
+
+  // Runs the given callback, clearing the given scoped_refptr before execution.
+  // This is useful for cases where there can be only one pending callback, and
+  // the presence of the callback indicates is one is pending. Such code would
+  // normally want to clear it before execution so the plugin can issue a new
+  // request.
+  static void ClearAndRun(scoped_refptr<TrackedCallback>* callback,
+                          int32_t result);
+
+  // Same as ClearAndRun except it calls Abort().
+  static void ClearAndAbort(scoped_refptr<TrackedCallback>* callback);
+
  private:
   // This class is ref counted.
   friend class base::RefCountedThreadSafe<TrackedCallback>;
   virtual ~TrackedCallback();
 
   // Mark this object as complete and remove it from the tracker. This must only
   // be called once. Note that running this may result in this object being
   // deleted (so keep a reference if it'll still be needed).
   void MarkAsCompleted();
 
   // Factory used by |PostAbort()|. Note that it's safe to cancel any pending
   // posted aborts on destruction -- before it's destroyed, the "owning"
   // |CallbackTracker| must have gone through and done (synchronous) |Abort()|s.
   base::WeakPtrFactory<TrackedCallback> abort_impl_factory_;
 
   scoped_refptr<CallbackTracker> tracker_;
   PP_Resource resource_id_;
   bool completed_;
   bool aborted_;
   PP_CompletionCallback callback_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(TrackedCallback);
 };
 
 }  // namespace ppapi
 
 #endif  // PPAPI_SHARED_IMPL_TRACKED_CALLBACK_H_