Change over IgnoreReturn to IgnoreResult. remove IgnoreReturn.

base/bind_helpers.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.
 
 // This defines a set of argument wrappers and related factory methods that
 // can be used specify the refcounting and reference semantics of arguments
 // that are bound by the Bind() function in base/bind.h.
 //
 // The public functions are base::Unretained(), base::Owned(), bass::Passed(),
 // base::ConstRef(), and base::IgnoreResult().
@@ skipping 112 matching lines @@
 // Passed() is particularly useful with PostTask() when you are transferring
 // ownership of an argument into a task, but don't necessarily know if the
 // task will always be executed. This can happen if the task is cancellable
 // or if it is posted to a MessageLoopProxy.
 
 #ifndef BASE_BIND_HELPERS_H_
 #define BASE_BIND_HELPERS_H_
 #pragma once
 
 #include "base/basictypes.h"
-#include "base/bind.h"
 #include "base/callback.h"
 #include "base/memory/weak_ptr.h"
 #include "base/template_util.h"
 
 namespace base {
 namespace internal {
 
 // Use the Substitution Failure Is Not An Error (SFINAE) trick to inspect T
 // for the existence of AddRef() and Release() functions of the correct
 // signature.
@@ skipping 311 matching lines @@
   static void AddRef(const scoped_refptr<T>& o) {}
   static void Release(const scoped_refptr<T>& o) {}
 };
 
 template <typename T>
 struct MaybeRefcount<true, const T*> {
   static void AddRef(const T* o) { o->AddRef(); }
   static void Release(const T* o) { o->Release(); }
 };
 
-template <typename R>
-void VoidReturnAdapter(Callback<R(void)> callback) {
-  callback.Run();
-}
-
 // IsWeakMethod is a helper that determine if we are binding a WeakPtr<> to a
 // method.  It is used internally by Bind() to select the correct
 // InvokeHelper that will no-op itself in the event the WeakPtr<> for
 // the target object is invalidated.
 //
 // P1 should be the type of the object that will be received of the method.
 template <bool IsMethod, typename P1>
 struct IsWeakMethod : public false_type {};
 
 template <typename T>
@@ skipping 25 matching lines @@
 // to write Passed(scoper.Pass()).
 template <typename T>
 static inline internal::PassedWrapper<T> Passed(T scoper) {
   return internal::PassedWrapper<T>(scoper.Pass());
 }
 template <typename T>
 static inline internal::PassedWrapper<T> Passed(T* scoper) {
   return internal::PassedWrapper<T>(scoper->Pass());
 }
 
-// -- DEPRECATED -- Use IgnoreResult instead.
-template <typename R>
-static inline Closure IgnoreReturn(Callback<R(void)> callback) {
-  return Bind(&internal::VoidReturnAdapter<R>, callback);
-}
-
 template <typename T>
 static inline internal::IgnoreResultHelper<T> IgnoreResult(T data) {
   return internal::IgnoreResultHelper<T>(data);
 }
 
 template <typename T>
 static inline internal::IgnoreResultHelper<Callback<T> >
 IgnoreResult(const Callback<T>& data) {
   return internal::IgnoreResultHelper<Callback<T> >(data);
 }
 
 }  // namespace base
 
 #endif  // BASE_BIND_HELPERS_H_