Made ObserverListThreadSafe's destructor private since it's ref-counted.

base/observer_list_threadsafe.h

 // Copyright (c) 2010 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_OBSERVER_LIST_THREADSAFE_H_
 #define BASE_OBSERVER_LIST_THREADSAFE_H_
 #pragma once
 
 #include <algorithm>
 #include <map>
@@ skipping 42 matching lines @@
 class ObserverListThreadSafe
     : public base::RefCountedThreadSafe<ObserverListThreadSafe<ObserverType> > {
  public:
   typedef typename ObserverList<ObserverType>::NotificationType
       NotificationType;
 
   ObserverListThreadSafe()
       : type_(ObserverListBase<ObserverType>::NOTIFY_ALL) {}
   explicit ObserverListThreadSafe(NotificationType type) : type_(type) {}
 
-  ~ObserverListThreadSafe() {
-    typename ObserversListMap::const_iterator it;
-    for (it = observer_lists_.begin(); it != observer_lists_.end(); ++it)
-      delete (*it).second;
-    observer_lists_.clear();
-  }
-
   // Add an observer to the list.
   void AddObserver(ObserverType* obs) {
     ObserverList<ObserverType>* list = NULL;
     MessageLoop* loop = MessageLoop::current();
     // TODO(mbelshe): Get rid of this check.  Its needed right now because
     //                Time currently triggers usage of the ObserverList.
     //                And unittests use time without a MessageLoop.
     if (!loop)
       return;  // Some unittests may access this without a message loop.
     {
@@ skipping 50 matching lines @@
 
   template <class Method, class A>
   void Notify(Method m, const A &a) {
     UnboundMethod<ObserverType, Method, Tuple1<A> > method(m, MakeTuple(a));
     Notify<Method, Tuple1<A> >(method);
   }
 
   // TODO(mbelshe):  Add more wrappers for Notify() with more arguments.
 
  private:
+  friend class
+      base::RefCountedThreadSafe<ObserverListThreadSafe<ObserverType> >;
+  ~ObserverListThreadSafe() {
+    typename ObserversListMap::const_iterator it;
+    for (it = observer_lists_.begin(); it != observer_lists_.end(); ++it)
+      delete (*it).second;
+    observer_lists_.clear();
+  }
+
   template <class Method, class Params>
   void Notify(const UnboundMethod<ObserverType, Method, Params>& method) {
     AutoLock lock(list_lock_);
     typename ObserversListMap::iterator it;
     for (it = observer_lists_.begin(); it != observer_lists_.end(); ++it) {
       MessageLoop* loop = (*it).first;
       ObserverList<ObserverType>* list = (*it).second;
       loop->PostTask(
           FROM_HERE,
           NewRunnableMethod(this,
@@ skipping 50 matching lines @@
 
   // These are marked mutable to facilitate having NotifyAll be const.
   Lock list_lock_;  // Protects the observer_lists_.
   ObserversListMap observer_lists_;
   const NotificationType type_;
 
   DISALLOW_COPY_AND_ASSIGN(ObserverListThreadSafe);
 };
 
 #endif  // BASE_OBSERVER_LIST_THREADSAFE_H_