Replace DispatchToMethod in ObserverListThreadSafe with Bind

base/observer_list_threadsafe.h

 // Copyright (c) 2012 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_
 
 #include <algorithm>
 #include <map>
 #include <tuple>
@@ skipping 43 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////
 
 namespace base {
 
 // Forward declaration for ObserverListThreadSafeTraits.
 template <class ObserverType>
 class ObserverListThreadSafe;
 
 namespace internal {
 
-// An UnboundMethod is a wrapper for a method where the actual object is
-// provided at Run dispatch time.
-template <class T, class Method, class Params>
-class UnboundMethod {
- public:
-  UnboundMethod(Method m, const Params& p) : m_(m), p_(p) {
-    static_assert((internal::ParamsUseScopedRefptrCorrectly<Params>::value),
-                  "bad unbound method params");

[dcheng, 2016/08/24 21:18:27]

If I understand correctly, the reason this is safe to remove is because we use
base::Bind() which already has these checks, right?

[tzik, 2016/08/25 00:53:01]

Yes, it's done in Bind().

+template <typename ObserverType, typename Method>
+struct Dispatcher;
+
+template <typename ObserverType, typename ReceiverType, typename... Params>
+struct Dispatcher<ObserverType, void(ReceiverType::*)(Params...)> {
+  static void Run(void(ReceiverType::* m)(Params...),
+                  Params... params, ObserverType* obj) {
+    (obj->*m)(std::forward<Params>(params)...);
   }
-  void Run(T* obj) const {
-    DispatchToMethod(obj, m_, p_);
-  }
- private:
-  Method m_;
-  Params p_;
 };
 
 }  // namespace internal
 
 // 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
@@ skipping 77 matching lines @@
   void AssertEmpty() const {
     AutoLock lock(list_lock_);
     DCHECK(observer_lists_.empty());
   }
 
   // Notify methods.
   // Make a thread-safe callback to each Observer in the list.
   // Note, these calls are effectively asynchronous.  You cannot assume
   // that at the completion of the Notify call that all Observers have
   // been Notified.  The notification may still be pending delivery.
-  template <class Method, class... Params>
+  template <typename Method, typename... Params>
   void Notify(const tracked_objects::Location& from_here,
-              Method m,
-              const Params&... params) {
-    internal::UnboundMethod<ObserverType, Method, std::tuple<Params...>> method(
-        m, std::make_tuple(params...));
+              Method m, Params&&... params) {
+    Callback<void(ObserverType*)> method =
+        Bind(&internal::Dispatcher<ObserverType, Method>::Run,
+             m, std::forward<Params>(params)...);
 
     AutoLock lock(list_lock_);
     for (const auto& entry : observer_lists_) {
       ObserverListContext* context = entry.second;
       context->task_runner->PostTask(
           from_here,
-          Bind(&ObserverListThreadSafe<ObserverType>::template NotifyWrapper<
-                   Method, std::tuple<Params...>>,
+          Bind(&ObserverListThreadSafe<ObserverType>::NotifyWrapper,
                this, context, method));
     }
   }
 
  private:
   // See comment above ObserverListThreadSafeTraits' definition.
   friend struct ObserverListThreadSafeTraits<ObserverType>;
 
   struct ObserverListContext {
     explicit ObserverListContext(NotificationType type)
         : task_runner(ThreadTaskRunnerHandle::Get()), list(type) {}
 
     scoped_refptr<SingleThreadTaskRunner> task_runner;
     ObserverList<ObserverType> list;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(ObserverListContext);
   };
 
   ~ObserverListThreadSafe() {
     STLDeleteValues(&observer_lists_);
   }
 
   // Wrapper which is called to fire the notifications for each thread's
   // ObserverList.  This function MUST be called on the thread which owns
   // the unsafe ObserverList.
-  template <class Method, class Params>
-  void NotifyWrapper(
-      ObserverListContext* context,
-      const internal::UnboundMethod<ObserverType, Method, Params>& method) {
+  void NotifyWrapper(ObserverListContext* context,
+                     const Callback<void(ObserverType*)>& method) {
     // Check that this list still needs notifications.
     {
       AutoLock lock(list_lock_);
       typename ObserversListMap::iterator it =
           observer_lists_.find(PlatformThread::CurrentId());
 
       // The ObserverList could have been removed already.  In fact, it could
       // have been removed and then re-added!  If the master list's loop
       // does not match this one, then we do not need to finish this
       // notification.
@@ skipping 34 matching lines @@
   mutable Lock list_lock_;  // Protects the observer_lists_.
   ObserversListMap observer_lists_;
   const NotificationType type_;
 
   DISALLOW_COPY_AND_ASSIGN(ObserverListThreadSafe);
 };
 
 }  // namespace base
 
 #endif  // BASE_OBSERVER_LIST_THREADSAFE_H_