Dispatch geolocation IPCs on the UI thread. Aside from simplifying the code to avoid a lot of threa…

base/callback_list.h.pump

 $$ This is a pump file for generating file templates.  Pump is a python
 $$ script that is part of the Google Test suite of utilities.  Description
 $$ can be found here:
 $$
 $$ http://code.google.com/p/googletest/wiki/PumpManual
 $$
 
 $$ See comment for MAX_ARITY in base/bind.h.pump.
 $var MAX_ARITY = 7
 
@@ skipping 76 matching lines @@
  public:
   class Subscription {
    public:
     Subscription(CallbackListBase<CallbackType>* list,
                  typename std::list<CallbackType>::iterator iter)
         : list_(list),
           iter_(iter) {
     }
 
     ~Subscription() {
-      if (list_->active_iterator_count_)
+      if (list_->active_iterator_count_) {
         iter_->Reset();
-      else
+      } else {
         list_->callbacks_.erase(iter_);
+        if (!list_->removal_callback_.is_null())
+          list_->removal_callback_.Run();
+      }
     }
 
    private:
     CallbackListBase<CallbackType>* list_;
     typename std::list<CallbackType>::iterator iter_;
 
     DISALLOW_COPY_AND_ASSIGN(Subscription);
   };
 
   // Add a callback to the list. The callback will remain registered until the
   // returned Subscription is destroyed, which must occur before the
   // CallbackList is destroyed.
   scoped_ptr<Subscription> Add(const CallbackType& cb) WARN_UNUSED_RESULT {
     DCHECK(!cb.is_null());
     return scoped_ptr<Subscription>(
         new Subscription(this, callbacks_.insert(callbacks_.end(), cb)));
   }
 
+  // Sets a callback which will be run when a subscription list is changed.
+  void set_removal_callback(const Closure& callback) {
+    removal_callback_ = callback;
+  }
+
+  bool empty() { return callbacks_.empty(); }

[dcheng, 2014/05/08 21:28:05]

Super duper minor driveby nit: I think this can be const-ified.

+
  protected:
   // An iterator class that can be used to access the list of callbacks.
   class Iterator {
    public:
     explicit Iterator(CallbackListBase<CallbackType>* list)
         : list_(list),
           list_iter_(list_->callbacks_.begin()) {
       ++list_->active_iterator_count_;
     }
 
@@ skipping 36 matching lines @@
   // Returns an instance of a CallbackListBase::Iterator which can be used
   // to run callbacks.
   Iterator GetIterator() {
     return Iterator(this);
   }
 
   // Compact the list: remove any entries which were NULLed out during
   // iteration.
   void Compact() {
     typename std::list<CallbackType>::iterator it = callbacks_.begin();
+    bool updated = false;
     while (it != callbacks_.end()) {
-      if ((*it).is_null())
+      if ((*it).is_null()) {
+        updated = true;
         it = callbacks_.erase(it);
-      else
+      } else {
         ++it;
+      }
+
+      if (updated && !removal_callback_.is_null())
+        removal_callback_.Run();
     }
   }
 
  private:
   std::list<CallbackType> callbacks_;
   int active_iterator_count_;
+  Closure removal_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(CallbackListBase);
 };
 
 }  // namespace internal
 
 template <typename Sig> class CallbackList;
 
 
 $range ARITY 0..MAX_ARITY
@@ skipping 42 matching lines @@
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CallbackList);
 };
 
 
 ]]  $$ for ARITY
 }  // namespace base
 
 #endif  // BASE_CALLBACK_LIST_H_