OLD | NEW |
| (Empty) |
1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 // ScopedCallbackFactory helps in cases where you wish to allocate a Callback | |
6 // (see base/callback.h), but need to prevent any pending callbacks from | |
7 // executing when your object gets destroyed. | |
8 // | |
9 // EXAMPLE: | |
10 // | |
11 // void GatherDataAsynchronously(Callback1<Data>::Type* callback); | |
12 // | |
13 // class MyClass { | |
14 // public: | |
15 // MyClass() : factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) { | |
16 // } | |
17 // | |
18 // void Process() { | |
19 // GatherDataAsynchronously(factory_.NewCallback(&MyClass::GotData)); | |
20 // } | |
21 // | |
22 // private: | |
23 // void GotData(const Data& data) { | |
24 // ... | |
25 // } | |
26 // | |
27 // base::ScopedCallbackFactory<MyClass> factory_; | |
28 // }; | |
29 // | |
30 // In the above example, the Process function calls GatherDataAsynchronously to | |
31 // kick off some asynchronous processing that upon completion will notify a | |
32 // callback. If in the meantime, the MyClass instance is destroyed, when the | |
33 // callback runs, it will notice that the MyClass instance is dead, and it will | |
34 // avoid calling the GotData method. | |
35 | |
36 #ifndef BASE_MEMORY_SCOPED_CALLBACK_FACTORY_H_ | |
37 #define BASE_MEMORY_SCOPED_CALLBACK_FACTORY_H_ | |
38 | |
39 #include "base/callback_old.h" | |
40 #include "base/memory/weak_ptr.h" | |
41 | |
42 namespace base { | |
43 | |
44 template <class T> | |
45 class ScopedCallbackFactory { | |
46 public: | |
47 explicit ScopedCallbackFactory(T* obj) : weak_factory_(obj) { | |
48 } | |
49 | |
50 typename Callback0::Type* NewCallback( | |
51 void (T::*method)()) { | |
52 return new CallbackImpl<void (T::*)(), Tuple0 >( | |
53 weak_factory_.GetWeakPtr(), method); | |
54 } | |
55 | |
56 template <typename Arg1> | |
57 typename Callback1<Arg1>::Type* NewCallback( | |
58 void (T::*method)(Arg1)) { | |
59 return new CallbackImpl<void (T::*)(Arg1), Tuple1<Arg1> >( | |
60 weak_factory_.GetWeakPtr(), method); | |
61 } | |
62 | |
63 template <typename Arg1, typename Arg2> | |
64 typename Callback2<Arg1, Arg2>::Type* NewCallback( | |
65 void (T::*method)(Arg1, Arg2)) { | |
66 return new CallbackImpl<void (T::*)(Arg1, Arg2), Tuple2<Arg1, Arg2> >( | |
67 weak_factory_.GetWeakPtr(), method); | |
68 } | |
69 | |
70 template <typename Arg1, typename Arg2, typename Arg3> | |
71 typename Callback3<Arg1, Arg2, Arg3>::Type* NewCallback( | |
72 void (T::*method)(Arg1, Arg2, Arg3)) { | |
73 return new CallbackImpl<void (T::*)(Arg1, Arg2, Arg3), | |
74 Tuple3<Arg1, Arg2, Arg3> >( | |
75 weak_factory_.GetWeakPtr(), method); | |
76 } | |
77 | |
78 template <typename Arg1, typename Arg2, typename Arg3, typename Arg4> | |
79 typename Callback4<Arg1, Arg2, Arg3, Arg4>::Type* NewCallback( | |
80 void (T::*method)(Arg1, Arg2, Arg3, Arg4)) { | |
81 return new CallbackImpl<void (T::*)(Arg1, Arg2, Arg3, Arg4), | |
82 Tuple4<Arg1, Arg2, Arg3, Arg4> >( | |
83 weak_factory_.GetWeakPtr(), method); | |
84 } | |
85 | |
86 template <typename Arg1, typename Arg2, typename Arg3, typename Arg4, | |
87 typename Arg5> | |
88 typename Callback5<Arg1, Arg2, Arg3, Arg4, Arg5>::Type* NewCallback( | |
89 void (T::*method)(Arg1, Arg2, Arg3, Arg4, Arg5)) { | |
90 return new CallbackImpl<void (T::*)(Arg1, Arg2, Arg3, Arg4, Arg5), | |
91 Tuple5<Arg1, Arg2, Arg3, Arg4, Arg5> >( | |
92 weak_factory_.GetWeakPtr(), method); | |
93 } | |
94 | |
95 void RevokeAll() { weak_factory_.InvalidateWeakPtrs(); } | |
96 bool HasPendingCallbacks() const { return weak_factory_.HasWeakPtrs(); } | |
97 | |
98 private: | |
99 template <typename Method> | |
100 class CallbackStorage { | |
101 public: | |
102 CallbackStorage(const WeakPtr<T>& obj, Method meth) | |
103 : obj_(obj), | |
104 meth_(meth) { | |
105 } | |
106 | |
107 protected: | |
108 WeakPtr<T> obj_; | |
109 Method meth_; | |
110 }; | |
111 | |
112 template <typename Method, typename Params> | |
113 class CallbackImpl : public CallbackStorage<Method>, | |
114 public CallbackRunner<Params> { | |
115 public: | |
116 CallbackImpl(const WeakPtr<T>& obj, Method meth) | |
117 : CallbackStorage<Method>(obj, meth) { | |
118 } | |
119 virtual void RunWithParams(const Params& params) { | |
120 // Use "this->" to force C++ to look inside our templatized base class; | |
121 // see Effective C++, 3rd Ed, item 43, p210 for details. | |
122 if (!this->obj_) | |
123 return; | |
124 DispatchToMethod(this->obj_.get(), this->meth_, params); | |
125 } | |
126 }; | |
127 | |
128 WeakPtrFactory<T> weak_factory_; | |
129 }; | |
130 | |
131 } // namespace base | |
132 | |
133 #endif // BASE_MEMORY_SCOPED_CALLBACK_FACTORY_H_ | |
OLD | NEW |