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

base/callback_list.h

 // This file was GENERATED by command:
 //     pump.py callback_list.h.pump
 // DO NOT EDIT BY HAND!!!
 
 
 // Copyright 2013 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 BASE_CALLBACK_LIST_H_
@@ skipping 71 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(); }

[Cait (Slow), 2014/05/09 20:11:13]

Note that this will only return true when the active_iterator_count has gone to
0 and Compact() has run. 

In your case I think this is fine, b/c it gets called by your removal callback,
which only runs at those times anyways, but maybe add a comment to this effect,
to avoid confusion in future.

[jam, 2014/05/09 20:30:52]

good point, thanks. i added a dcheck to ensure this. if someone later wants to
use it during iteration, which seems unlikely, we can make it support that case
then.

+
  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;
 
 template <>
 class CallbackList<void(void)>
@@ skipping 184 matching lines @@
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CallbackList);
 };
 
 }  // namespace base
 
 #endif  // BASE_CALLBACK_LIST_H_