Remove NewRequiredCallback.

ppapi/utility/completion_callback_factory.h

 // Copyright (c) 2011 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 PPAPI_UTILITY_COMPLETION_CALLBACK_FACTORY_H_
 #define PPAPI_UTILITY_COMPLETION_CALLBACK_FACTORY_H_
 
 #include "ppapi/cpp/completion_callback.h"
 #include "ppapi/utility/non_thread_safe_ref_count.h"
 
@@ skipping 21 matching lines @@
 /// @code
 ///
 ///   class MyHandler {
 ///    public:
 ///     // If an compiler warns on following using |this| in the initializer
 ///     // list, use PP_ALLOW_THIS_IN_INITIALIZER_LIST macro.
 ///     MyHandler() : factory_(this), offset_(0) {
 ///     }
 ///
 ///    void ProcessFile(const FileRef& file) {
-///       CompletionCallback cc = factory_.NewRequiredCallback(
+///       CompletionCallback cc = factory_.NewCallback(
 ///           &MyHandler::DidOpen);
 ///       int32_t rv = fio_.Open(file, PP_FileOpenFlag_Read, cc);
 ///       CHECK(rv == PP_OK_COMPLETIONPENDING);
 ///     }
 ///
 ///    private:
 ///     CompletionCallback NewCallback() {
 ///       return factory_.NewCallback(&MyHandler::DidCompleteIO);
 ///     }
 ///
@@ skipping 87 matching lines @@
   /// Intialize().
   ///
   /// @return the object passed to the constructor or Intialize().
   T* GetObject() {
     return object_;
   }
 
   /// NewCallback allocates a new, single-use <code>CompletionCallback</code>.
   /// The <code>CompletionCallback</code> must be run in order for the memory
   /// allocated by the methods to be freed.
-  /// NewCallback() is equivalent to NewRequiredCallback() below.
+  /// NewCallback() is equivalent to NewCallback() below.

[viettrungluu, 2012/03/09 06:16:24]

This was not your finest search-and-replace moment. (But somehow you got the
other ones right.)

   ///
   /// @param[in] method The method to be invoked upon completion of the
   /// operation.
   ///
   /// @return A <code>CompletionCallback</code>.
   template <typename Method>
   CompletionCallback NewCallback(Method method) {
     PP_DCHECK(object_);
     return NewCallbackHelper(Dispatcher0<Method>(method));
   }
 
-  /// NewRequiredCallback() allocates a new, single-use
-  /// <code>CompletionCallback</code> that will always run. The
-  /// <code>CompletionCallback</code> must be run in order for the memory
-  /// allocated by the methods to be freed.
-  ///
-  /// @param[in] method The method to be invoked upon completion of the
-  /// operation.
-  ///
-  /// @return A <code>CompletionCallback</code>.
-  template <typename Method>
-  CompletionCallback NewRequiredCallback(Method method) {
-    CompletionCallback cc = NewCallback(method);
-    cc.set_flags(cc.flags() & ~PP_COMPLETIONCALLBACK_FLAG_OPTIONAL);
-    return cc;
-  }
-
   /// NewOptionalCallback() allocates a new, single-use
   /// <code>CompletionCallback</code> that might not run if the method
   /// taking it can complete synchronously. Thus, if after passing the
   /// CompletionCallback to a Pepper method, the method does not return
   /// PP_OK_COMPLETIONPENDING, then you should manually call the
   /// CompletionCallback's Run method, or memory will be leaked.
   ///
   /// @param[in] method The method to be invoked upon completion of the
   /// operation.
   ///
   /// @return A <code>CompletionCallback</code>.
   template <typename Method>
   CompletionCallback NewOptionalCallback(Method method) {
     CompletionCallback cc = NewCallback(method);
     cc.set_flags(cc.flags() | PP_COMPLETIONCALLBACK_FLAG_OPTIONAL);
     return cc;
   }
 
   /// NewCallback() allocates a new, single-use <code>CompletionCallback</code>.
   /// The <code>CompletionCallback</code> must be run in order for the memory
   /// allocated by the methods to be freed.
-  /// NewCallback() is equivalent to NewRequiredCallback() below.
   ///
   /// @param[in] method The method to be invoked upon completion of the
   /// operation. Method should be of type:
   /// <code>void (T::*)(int32_t result, const A& a)</code>
   ///
   /// @param[in] a Passed to <code>method</code> when the completion callback
   /// runs.
   ///
   /// @return A <code>CompletionCallback</code>.
   template <typename Method, typename A>
   CompletionCallback NewCallback(Method method, const A& a) {
     PP_DCHECK(object_);
     return NewCallbackHelper(Dispatcher1<Method, A>(method, a));
   }
 
-  /// NewRequiredCallback() allocates a new, single-use
-  /// <code>CompletionCallback</code> that will always run. The
-  /// <code>CompletionCallback</code> must be run in order for the memory
-  /// allocated by the methods to be freed.
-  ///
-  /// @param[in] method The method to be invoked upon completion of the
-  /// operation. Method should be of type:
-  /// <code>void (T::*)(int32_t result, const A& a)</code>
-  ///
-  /// @param[in] a Passed to <code>method</code> when the completion callback
-  /// runs.
-  ///
-  /// @return A <code>CompletionCallback</code>.
-  template <typename Method, typename A>
-  CompletionCallback NewRequiredCallback(Method method, const A& a) {
-    CompletionCallback cc = NewCallback(method, a);
-    cc.set_flags(cc.flags() & ~PP_COMPLETIONCALLBACK_FLAG_OPTIONAL);
-    return cc;
-  }
-
-  /// NewOptionalCallback() allocates a new, single-use
   /// <code>CompletionCallback</code> that might not run if the method
   /// taking it can complete synchronously. Thus, if after passing the
   /// CompletionCallback to a Pepper method, the method does not return
   /// PP_OK_COMPLETIONPENDING, then you should manually call the
   /// CompletionCallback's Run method, or memory will be leaked.
   ///
   /// @param[in] method The method to be invoked upon completion of the
   /// operation. Method should be of type:
   /// <code>void (T::*)(int32_t result, const A& a)</code>
   ///
   /// @param[in] a Passed to <code>method</code> when the completion callback
   /// runs.
   ///
   /// @return A <code>CompletionCallback</code>.
   template <typename Method, typename A>
   CompletionCallback NewOptionalCallback(Method method, const A& a) {
     CompletionCallback cc = NewCallback(method, a);
     cc.set_flags(cc.flags() | PP_COMPLETIONCALLBACK_FLAG_OPTIONAL);
     return cc;
   }
 
   /// NewCallback() allocates a new, single-use
   /// <code>CompletionCallback</code>.
   /// The <code>CompletionCallback</code> must be run in order for the memory
   /// allocated by the methods to be freed.
-  /// NewCallback() is equivalent to NewRequiredCallback() below.
   ///
   /// @param method The method taking the callback. Method should be of type:
   /// <code>void (T::*)(int32_t result, const A& a, const B& b)</code>
   ///
   /// @param[in] a Passed to <code>method</code> when the completion callback
   /// runs.
   ///
   /// @param[in] b Passed to <code>method</code> when the completion callback
   /// runs.
   ///
   /// @return A <code>CompletionCallback</code>.
   template <typename Method, typename A, typename B>
   CompletionCallback NewCallback(Method method, const A& a, const B& b) {
     PP_DCHECK(object_);
     return NewCallbackHelper(Dispatcher2<Method, A, B>(method, a, b));
   }
 
-  /// NewRequiredCallback() allocates a new, single-use
-  /// <code>CompletionCallback</code> that will always run. The
-  /// <code>CompletionCallback</code> must be run in order for the memory
-  /// allocated by the methods to be freed.
-  ///
-  /// @param method The method taking the callback. Method should be of type:
-  /// <code>void (T::*)(int32_t result, const A& a, const B& b)</code>
-  ///
-  /// @param[in] a Passed to <code>method</code> when the completion callback
-  /// runs.
-  ///
-  /// @param[in] b Passed to <code>method</code> when the completion callback
-  /// runs.
-  ///
-  /// @return A <code>CompletionCallback</code>.
-  template <typename Method, typename A, typename B>
-  CompletionCallback NewRequiredCallback(Method method, const A& a,
-                                         const B& b) {
-    CompletionCallback cc = NewCallback(method, a, b);
-    cc.set_flags(cc.flags() & ~PP_COMPLETIONCALLBACK_FLAG_OPTIONAL);
-    return cc;
-  }
-
   /// NewOptionalCallback() allocates a new, single-use
   /// <code>CompletionCallback</code> that might not run if the method
   /// taking it can complete synchronously. Thus, if after passing the
   /// CompletionCallback to a Pepper method, the method does not return
   /// PP_OK_COMPLETIONPENDING, then you should manually call the
   /// CompletionCallback's Run method, or memory will be leaked.
   ///
   /// @param[in] method The method taking the callback. Method should be of
   /// type:
   /// <code>void (T::*)(int32_t result, const A& a, const B& b)</code>
@@ skipping 10 matching lines @@
                                          const B& b) {
     CompletionCallback cc = NewCallback(method, a, b);
     cc.set_flags(cc.flags() | PP_COMPLETIONCALLBACK_FLAG_OPTIONAL);
     return cc;
   }
 
   /// NewCallback() allocates a new, single-use
   /// <code>CompletionCallback</code>.
   /// The <code>CompletionCallback</code> must be run in order for the memory
   /// allocated by the methods to be freed.
-  /// NewCallback() is equivalent to NewRequiredCallback() below.
   ///
   /// @param method The method taking the callback. Method should be of type:
   /// <code>
   /// void (T::*)(int32_t result, const A& a, const B& b, const C& c)
   /// </code>
   ///
   /// @param[in] a Passed to <code>method</code> when the completion callback
   /// runs.
   ///
   /// @param[in] b Passed to <code>method</code> when the completion callback
   /// runs.
   ///
   /// @param[in] c Passed to <code>method</code> when the completion callback
   /// runs.
   ///
   /// @return A <code>CompletionCallback</code>.
   template <typename Method, typename A, typename B, typename C>
   CompletionCallback NewCallback(Method method, const A& a, const B& b,
                                  const C& c) {
     PP_DCHECK(object_);
     return NewCallbackHelper(Dispatcher3<Method, A, B, C>(method, a, b, c));
   }
 
-  /// NewRequiredCallback() allocates a new, single-use
-  /// <code>CompletionCallback</code> that will always run. The
-  /// <code>CompletionCallback</code> must be run in order for the memory
-  /// allocated by the methods to be freed.
-  ///
-  /// @param method The method taking the callback. Method should be of type:
-  /// <code>
-  /// void (T::*)(int32_t result, const A& a, const B& b, const C& c)
-  /// </code>
-  ///
-  /// @param[in] a Passed to <code>method</code> when the completion callback
-  /// runs.
-  ///
-  /// @param[in] b Passed to <code>method</code> when the completion callback
-  /// runs.
-  ///
-  /// @param[in] c Passed to <code>method</code> when the completion callback
-  /// runs.
-  ///
-  /// @return A <code>CompletionCallback</code>.
-  template <typename Method, typename A, typename B, typename C>
-  CompletionCallback NewRequiredCallback(Method method, const A& a,
-                                         const B& b, const C& c) {
-    CompletionCallback cc = NewCallback(method, a, b, c);
-    cc.set_flags(cc.flags() & ~PP_COMPLETIONCALLBACK_FLAG_OPTIONAL);
-    return cc;
-  }
-
   /// NewOptionalCallback() allocates a new, single-use
   /// <code>CompletionCallback</code> that might not run if the method
   /// taking it can complete synchronously. Thus, if after passing the
   /// CompletionCallback to a Pepper method, the method does not return
   /// PP_OK_COMPLETIONPENDING, then you should manually call the
   /// CompletionCallback's Run method, or memory will be leaked.
   ///
   /// @param[in] method The method taking the callback. Method should be of
   /// type:
   /// <code>
@@ skipping 161 matching lines @@
   CompletionCallbackFactory(const CompletionCallbackFactory&);
   CompletionCallbackFactory& operator=(const CompletionCallbackFactory&);
 
   T* object_;
   BackPointer* back_pointer_;
 };
 
 }  // namespace pp
 
 #endif  // PPAPI_UTILITY_COMPLETION_CALLBACK_FACTORY_H_