Add workaround for VS2005 compile error introduced by r70933

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 31 matching lines @@
 //   whereas with the non-thread-safe observer_list, notifications happen
 //   synchronously and immediately.
 //
 //   IMPLEMENTATION NOTES
 //   The ObserverListThreadSafe maintains an ObserverList for each thread
 //   which uses the ThreadSafeObserver.  When Notifying the observers,
 //   we simply call PostTask to each registered thread, and then each thread
 //   will notify its regular ObserverList.
 //
 ///////////////////////////////////////////////////////////////////////////////
+
+// Forward declaration for ObserverListThreadSafeTraits.
+template <class ObserverType>
+class ObserverListThreadSafe;
+
+// This class is used to work around VS2005 not accepting:
+//
+// friend class
+//     base::RefCountedThreadSafe<ObserverListThreadSafe<ObserverType> >;
+//
+// Instead of friending the class, we could friend the actual function
+// which calls delete.  However, this ends up being
+// RefCountedThreadSafe::DeleteInternal(), which is private.  So we
+// define our own templated traits class so we can friend it.
+template <class T>
+struct ObserverListThreadSafeTraits {
+  static void Destruct(const ObserverListThreadSafe<T>* x) {
+    delete x;
+  }
+};
+
 template <class ObserverType>
 class ObserverListThreadSafe
-    : public base::RefCountedThreadSafe<ObserverListThreadSafe<ObserverType> > {
+    : public base::RefCountedThreadSafe<
+        ObserverListThreadSafe<ObserverType>,
+        ObserverListThreadSafeTraits<ObserverType> > {
  public:
   typedef typename ObserverList<ObserverType>::NotificationType
       NotificationType;
 
   ObserverListThreadSafe()
       : type_(ObserverListBase<ObserverType>::NOTIFY_ALL) {}
   explicit ObserverListThreadSafe(NotificationType type) : type_(type) {}
 
   // Add an observer to the list.
   void AddObserver(ObserverType* obs) {
@@ skipping 58 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> >;
+  // See comment above ObserverListThreadSafeTraits' definition.
+  friend struct ObserverListThreadSafeTraits<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_);
@@ skipping 57 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_