third_party/protobuf: Update to HEAD (f52e188fe4)

third_party/protobuf/src/google/protobuf/stubs/callback.h

 #ifndef GOOGLE_PROTOBUF_STUBS_CALLBACK_H_
 #define GOOGLE_PROTOBUF_STUBS_CALLBACK_H_
 
 #include <google/protobuf/stubs/macros.h>
 #include <google/protobuf/stubs/type_traits.h>
 
 // ===================================================================
 // emulates google3/base/callback.h
 
 namespace google {
@@ skipping 328 matching lines @@
   bool self_deleting_;
   P1 p1_;
 };
 
 template <typename T>
 struct InternalConstRef {
   typedef typename remove_reference<T>::type base_type;
   typedef const base_type& type;
 };
 
+template<typename R, typename T>
+class MethodResultCallback_0_0 : public ResultCallback<R> {
+ public:
+  typedef R (T::*MethodType)();
+  MethodResultCallback_0_0(T* object, MethodType method, bool self_deleting)
+      : object_(object),
+        method_(method),
+        self_deleting_(self_deleting) {}
+  ~MethodResultCallback_0_0() {}
+
+  R Run() {
+    bool needs_delete = self_deleting_;
+    R result = (object_->*method_)();
+    if (needs_delete) delete this;
+    return result;
+  }
+
+ private:
+  T* object_;
+  MethodType method_;
+  bool self_deleting_;
+};
+
 template <typename R, typename T, typename P1, typename P2, typename P3,
           typename P4, typename P5, typename A1, typename A2>
 class MethodResultCallback_5_2 : public ResultCallback2<R, A1, A2> {
  public:
   typedef R (T::*MethodType)(P1, P2, P3, P4, P5, A1, A2);
   MethodResultCallback_5_2(T* object, MethodType method, bool self_deleting,
                            P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
       : object_(object),
         method_(method),
         self_deleting_(self_deleting),
@@ skipping 15 matching lines @@
   T* object_;
   MethodType method_;
   bool self_deleting_;
   typename remove_reference<P1>::type p1_;
   typename remove_reference<P2>::type p2_;
   typename remove_reference<P3>::type p3_;
   typename remove_reference<P4>::type p4_;
   typename remove_reference<P5>::type p5_;
 };
 
+}  // namespace internal
+
 // See Closure.
 inline Closure* NewCallback(void (*function)()) {
   return new internal::FunctionClosure0(function, true);
 }
 
 // See Closure.
 inline Closure* NewPermanentCallback(void (*function)()) {
   return new internal::FunctionClosure0(function, false);
 }
 
@@ skipping 117 matching lines @@
 }
 
 // See ResultCallback1
 template<typename R, typename P1, typename A1>
 inline ResultCallback1<R, A1>* NewPermanentCallback(
     R (*function)(P1, A1), P1 p1) {
   return new internal::FunctionResultCallback_1_1<R, P1, A1>(
       function, false, p1);
 }
 
+// See MethodResultCallback_0_0
+template <typename R, typename T1, typename T2>
+inline ResultCallback<R>* NewPermanentCallback(
+    T1* object, R (T2::*function)()) {
+  return new internal::MethodResultCallback_0_0<R, T1>(object, function, false);
+}
+
 // See MethodResultCallback_5_2
 template <typename R, typename T, typename P1, typename P2, typename P3,
           typename P4, typename P5, typename A1, typename A2>
 inline ResultCallback2<R, A1, A2>* NewPermanentCallback(
     T* object, R (T::*function)(P1, P2, P3, P4, P5, A1, A2),
     typename internal::InternalConstRef<P1>::type p1,
     typename internal::InternalConstRef<P2>::type p2,
     typename internal::InternalConstRef<P3>::type p3,
     typename internal::InternalConstRef<P4>::type p4,
     typename internal::InternalConstRef<P5>::type p5) {
   return new internal::MethodResultCallback_5_2<R, T, P1, P2, P3, P4, P5, A1,
                                                 A2>(object, function, false, p1,
                                                     p2, p3, p4, p5);
 }
 
-}  // namespace internal
-
 // A function which does nothing.  Useful for creating no-op callbacks, e.g.:
 //   Closure* nothing = NewCallback(&DoNothing);
 void LIBPROTOBUF_EXPORT DoNothing();
 
 
 }  // namespace protobuf
 }  // namespace google
 
 #endif  // GOOGLE_PROTOBUF_STUBS_CALLBACK_H_