Replace typedef with using for Callback/Bind related files

base/bind_unittest.cc

 // 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.
 
 #include "base/bind.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::Mock;
 using ::testing::Return;
 using ::testing::StrictMock;
 
 namespace base {
 namespace {
 
 class IncompleteType;
 
 class NoRef {
  public:
   NoRef() {}
 
-  MOCK_METHOD0(VoidMethod0, void(void));
-  MOCK_CONST_METHOD0(VoidConstMethod0, void(void));
+  MOCK_METHOD0(VoidMethod0, void());
+  MOCK_CONST_METHOD0(VoidConstMethod0, void());
 
-  MOCK_METHOD0(IntMethod0, int(void));
-  MOCK_CONST_METHOD0(IntConstMethod0, int(void));
+  MOCK_METHOD0(IntMethod0, int());
+  MOCK_CONST_METHOD0(IntConstMethod0, int());
 
  private:
   // Particularly important in this test to ensure no copies are made.
   DISALLOW_COPY_AND_ASSIGN(NoRef);
 };
 
 class HasRef : public NoRef {
  public:
   HasRef() {}
 
-  MOCK_CONST_METHOD0(AddRef, void(void));
-  MOCK_CONST_METHOD0(Release, bool(void));
+  MOCK_CONST_METHOD0(AddRef, void());
+  MOCK_CONST_METHOD0(Release, bool());
 
  private:
   // Particularly important in this test to ensure no copies are made.
   DISALLOW_COPY_AND_ASSIGN(HasRef);
 };
 
 class HasRefPrivateDtor : public HasRef {
  private:
   ~HasRefPrivateDtor() {}
 };
 
 static const int kParentValue = 1;
 static const int kChildValue = 2;
 
 class Parent {
  public:
-  void AddRef(void) const {}
-  void Release(void) const {}
+  void AddRef() const {}
+  void Release() const {}
   virtual void VirtualSet() { value = kParentValue; }
   void NonVirtualSet() { value = kParentValue; }
   int value;
 };
 
 class Child : public Parent {
  public:
   void VirtualSet() override { value = kChildValue; }
   void NonVirtualSet() { value = kChildValue; }
 };
@@ skipping 148 matching lines @@
  public:
   BindTest() {
     const_has_ref_ptr_ = &has_ref_;
     const_no_ref_ptr_ = &no_ref_;
     static_func_mock_ptr = &static_func_mock_;
   }
 
   virtual ~BindTest() {
   }
 
-  static void VoidFunc0(void) {
+  static void VoidFunc0() {
     static_func_mock_ptr->VoidMethod0();
   }
 
-  static int IntFunc0(void) { return static_func_mock_ptr->IntMethod0(); }
+  static int IntFunc0() { return static_func_mock_ptr->IntMethod0(); }
 
  protected:
   StrictMock<NoRef> no_ref_;
   StrictMock<HasRef> has_ref_;
   const HasRef* const_has_ref_ptr_;
   const NoRef* const_no_ref_ptr_;
   StrictMock<NoRef> static_func_mock_;
 
   // Used by the static functions to perform expectations.
   static StrictMock<NoRef>* static_func_mock_ptr;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BindTest);
 };
 
 StrictMock<NoRef>* BindTest::static_func_mock_ptr;
 
 // Sanity check that we can instantiate a callback for each arity.
 TEST_F(BindTest, ArityTest) {
-  Callback<int(void)> c0 = Bind(&Sum, 32, 16, 8, 4, 2, 1);
+  Callback<int()> c0 = Bind(&Sum, 32, 16, 8, 4, 2, 1);
   EXPECT_EQ(63, c0.Run());
 
   Callback<int(int)> c1 = Bind(&Sum, 32, 16, 8, 4, 2);
   EXPECT_EQ(75, c1.Run(13));
 
   Callback<int(int,int)> c2 = Bind(&Sum, 32, 16, 8, 4);
   EXPECT_EQ(85, c2.Run(13, 12));
 
   Callback<int(int,int,int)> c3 = Bind(&Sum, 32, 16, 8);
   EXPECT_EQ(92, c3.Run(13, 12, 11));
@@ skipping 21 matching lines @@
 
   Callback<int(int,int,int)> c3 = Bind(c4, 8);
   EXPECT_EQ(92, c3.Run(13, 12, 11));
 
   Callback<int(int,int)> c2 = Bind(c3, 4);
   EXPECT_EQ(85, c2.Run(13, 12));
 
   Callback<int(int)> c1 = Bind(c2, 2);
   EXPECT_EQ(75, c1.Run(13));
 
-  Callback<int(void)> c0 = Bind(c1, 1);
+  Callback<int()> c0 = Bind(c1, 1);
   EXPECT_EQ(63, c0.Run());
 }
 
 // Test that currying the rvalue result of another Bind() works correctly.
 //   - rvalue should be usable as argument to Bind().
 //   - multiple runs of resulting Callback remain valid.
 TEST_F(BindTest, CurryingRvalueResultOfBind) {
   int n = 0;
   Closure cb = base::Bind(&TakesACallback, base::Bind(&PtrArgSet, &n));
 
@@ skipping 20 matching lines @@
 //   - Derived classes can be used with pointers to virtual base functions (and
 //     preserve virtual dispatch).
 TEST_F(BindTest, FunctionTypeSupport) {
   EXPECT_CALL(static_func_mock_, VoidMethod0());
   EXPECT_CALL(has_ref_, AddRef()).Times(5);
   EXPECT_CALL(has_ref_, Release()).Times(5);
   EXPECT_CALL(has_ref_, VoidMethod0()).Times(2);
   EXPECT_CALL(has_ref_, VoidConstMethod0()).Times(2);
 
   Closure normal_cb = Bind(&VoidFunc0);
-  Callback<NoRef*(void)> normal_non_refcounted_cb =
+  Callback<NoRef*()> normal_non_refcounted_cb =
       Bind(&PolymorphicIdentity<NoRef*>, &no_ref_);
   normal_cb.Run();
   EXPECT_EQ(&no_ref_, normal_non_refcounted_cb.Run());
 
   Closure method_cb = Bind(&HasRef::VoidMethod0, &has_ref_);
   Closure method_refptr_cb = Bind(&HasRef::VoidMethod0,
                                   make_scoped_refptr(&has_ref_));
   Closure const_method_nonconst_obj_cb = Bind(&HasRef::VoidConstMethod0,
                                               &has_ref_);
   Closure const_method_const_obj_cb = Bind(&HasRef::VoidConstMethod0,
@@ skipping 21 matching lines @@
 //   - Const method with return value.
 TEST_F(BindTest, ReturnValues) {
   EXPECT_CALL(static_func_mock_, IntMethod0()).WillOnce(Return(1337));
   EXPECT_CALL(has_ref_, AddRef()).Times(3);
   EXPECT_CALL(has_ref_, Release()).Times(3);
   EXPECT_CALL(has_ref_, IntMethod0()).WillOnce(Return(31337));
   EXPECT_CALL(has_ref_, IntConstMethod0())
       .WillOnce(Return(41337))
       .WillOnce(Return(51337));
 
-  Callback<int(void)> normal_cb = Bind(&IntFunc0);
-  Callback<int(void)> method_cb = Bind(&HasRef::IntMethod0, &has_ref_);
-  Callback<int(void)> const_method_nonconst_obj_cb =
+  Callback<int()> normal_cb = Bind(&IntFunc0);
+  Callback<int()> method_cb = Bind(&HasRef::IntMethod0, &has_ref_);
+  Callback<int()> const_method_nonconst_obj_cb =
       Bind(&HasRef::IntConstMethod0, &has_ref_);
-  Callback<int(void)> const_method_const_obj_cb =
+  Callback<int()> const_method_const_obj_cb =
       Bind(&HasRef::IntConstMethod0, const_has_ref_ptr_);
   EXPECT_EQ(1337, normal_cb.Run());
   EXPECT_EQ(31337, method_cb.Run());
   EXPECT_EQ(41337, const_method_nonconst_obj_cb.Run());
   EXPECT_EQ(51337, const_method_const_obj_cb.Run());
 }
 
 // IgnoreResult adapter test.
 //   - Function with return value.
 //   - Method with return value.
@@ skipping 43 matching lines @@
 //   - Argument binding to a literal string.
 //   - Argument binding with template function.
 //   - Argument binding to an object.
 //   - Argument binding to pointer to incomplete type.
 //   - Argument gets type converted.
 //   - Pointer argument gets converted.
 //   - Const Reference forces conversion.
 TEST_F(BindTest, ArgumentBinding) {
   int n = 2;
 
-  Callback<int(void)> bind_primitive_cb = Bind(&Identity, n);
+  Callback<int()> bind_primitive_cb = Bind(&Identity, n);
   EXPECT_EQ(n, bind_primitive_cb.Run());
 
-  Callback<int*(void)> bind_primitive_pointer_cb =
+  Callback<int*()> bind_primitive_pointer_cb =
       Bind(&PolymorphicIdentity<int*>, &n);
   EXPECT_EQ(&n, bind_primitive_pointer_cb.Run());
 
-  Callback<int(void)> bind_int_literal_cb = Bind(&Identity, 3);
+  Callback<int()> bind_int_literal_cb = Bind(&Identity, 3);
   EXPECT_EQ(3, bind_int_literal_cb.Run());
 
-  Callback<const char*(void)> bind_string_literal_cb =
+  Callback<const char*()> bind_string_literal_cb =
       Bind(&CStringIdentity, "hi");
   EXPECT_STREQ("hi", bind_string_literal_cb.Run());
 
-  Callback<int(void)> bind_template_function_cb =
+  Callback<int()> bind_template_function_cb =
       Bind(&PolymorphicIdentity<int>, 4);
   EXPECT_EQ(4, bind_template_function_cb.Run());
 
   NoRefParent p;
   p.value = 5;
-  Callback<int(void)> bind_object_cb = Bind(&UnwrapNoRefParent, p);
+  Callback<int()> bind_object_cb = Bind(&UnwrapNoRefParent, p);
   EXPECT_EQ(5, bind_object_cb.Run());
 
   IncompleteType* incomplete_ptr = reinterpret_cast<IncompleteType*>(123);
-  Callback<IncompleteType*(void)> bind_incomplete_ptr_cb =
+  Callback<IncompleteType*()> bind_incomplete_ptr_cb =
       Bind(&PolymorphicIdentity<IncompleteType*>, incomplete_ptr);
   EXPECT_EQ(incomplete_ptr, bind_incomplete_ptr_cb.Run());
 
   NoRefChild c;
   c.value = 6;
-  Callback<int(void)> bind_promotes_cb = Bind(&UnwrapNoRefParent, c);
+  Callback<int()> bind_promotes_cb = Bind(&UnwrapNoRefParent, c);
   EXPECT_EQ(6, bind_promotes_cb.Run());
 
   c.value = 7;
-  Callback<int(void)> bind_pointer_promotes_cb =
+  Callback<int()> bind_pointer_promotes_cb =
       Bind(&UnwrapNoRefParentPtr, &c);
   EXPECT_EQ(7, bind_pointer_promotes_cb.Run());
 
   c.value = 8;
-  Callback<int(void)> bind_const_reference_promotes_cb =
+  Callback<int()> bind_const_reference_promotes_cb =
       Bind(&UnwrapNoRefParentConstRef, c);
   EXPECT_EQ(8, bind_const_reference_promotes_cb.Run());
 }
 
 // Unbound argument type support tests.
 //   - Unbound value.
 //   - Unbound pointer.
 //   - Unbound reference.
 //   - Unbound const reference.
 //   - Unbound unsized array.
@@ skipping 26 matching lines @@
 }
 
 // Functions that take reference parameters.
 //  - Forced reference parameter type still stores a copy.
 //  - Forced const reference parameter type still stores a copy.
 TEST_F(BindTest, ReferenceArgumentBinding) {
   int n = 1;
   int& ref_n = n;
   const int& const_ref_n = n;
 
-  Callback<int(void)> ref_copies_cb = Bind(&Identity, ref_n);
+  Callback<int()> ref_copies_cb = Bind(&Identity, ref_n);
   EXPECT_EQ(n, ref_copies_cb.Run());
   n++;
   EXPECT_EQ(n - 1, ref_copies_cb.Run());
 
-  Callback<int(void)> const_ref_copies_cb = Bind(&Identity, const_ref_n);
+  Callback<int()> const_ref_copies_cb = Bind(&Identity, const_ref_n);
   EXPECT_EQ(n, const_ref_copies_cb.Run());
   n++;
   EXPECT_EQ(n - 1, const_ref_copies_cb.Run());
 }
 
 // Check that we can pass in arrays and have them be stored as a pointer.
 //  - Array of values stores a pointer.
 //  - Array of const values stores a pointer.
 TEST_F(BindTest, ArrayArgumentBinding) {
   int array[4] = {1, 1, 1, 1};
   const int (*const_array_ptr)[4] = &array;
 
-  Callback<int(void)> array_cb = Bind(&ArrayGet, array, 1);
+  Callback<int()> array_cb = Bind(&ArrayGet, array, 1);
   EXPECT_EQ(1, array_cb.Run());
 
-  Callback<int(void)> const_array_cb = Bind(&ArrayGet, *const_array_ptr, 1);
+  Callback<int()> const_array_cb = Bind(&ArrayGet, *const_array_ptr, 1);
   EXPECT_EQ(1, const_array_cb.Run());
 
   array[1] = 3;
   EXPECT_EQ(3, array_cb.Run());
   EXPECT_EQ(3, const_array_cb.Run());
 }
 
 // Verify SupportsAddRefAndRelease correctly introspects the class type for
 // AddRef() and Release().
 //  - Class with AddRef() and Release()
@@ skipping 17 matching lines @@
 }
 
 // Unretained() wrapper support.
 //   - Method bound to Unretained() non-const object.
 //   - Const method bound to Unretained() non-const object.
 //   - Const method bound to Unretained() const object.
 TEST_F(BindTest, Unretained) {
   EXPECT_CALL(no_ref_, VoidMethod0());
   EXPECT_CALL(no_ref_, VoidConstMethod0()).Times(2);
 
-  Callback<void(void)> method_cb =
+  Callback<void()> method_cb =
       Bind(&NoRef::VoidMethod0, Unretained(&no_ref_));
   method_cb.Run();
 
-  Callback<void(void)> const_method_cb =
+  Callback<void()> const_method_cb =
       Bind(&NoRef::VoidConstMethod0, Unretained(&no_ref_));
   const_method_cb.Run();
 
-  Callback<void(void)> const_method_const_ptr_cb =
+  Callback<void()> const_method_const_ptr_cb =
       Bind(&NoRef::VoidConstMethod0, Unretained(const_no_ref_ptr_));
   const_method_const_ptr_cb.Run();
 }
 
 // WeakPtr() support.
 //   - Method bound to WeakPtr<> to non-const object.
 //   - Const method bound to WeakPtr<> to non-const object.
 //   - Const method bound to WeakPtr<> to const object.
 //   - Normal Function with WeakPtr<> as P1 can have return type and is
 //     not canceled.
@@ skipping 31 matching lines @@
   EXPECT_EQ(2, normal_func_cb.Run(2));
 }
 
 // ConstRef() wrapper support.
 //   - Binding w/o ConstRef takes a copy.
 //   - Binding a ConstRef takes a reference.
 //   - Binding ConstRef to a function ConstRef does not copy on invoke.
 TEST_F(BindTest, ConstRef) {
   int n = 1;
 
-  Callback<int(void)> copy_cb = Bind(&Identity, n);
-  Callback<int(void)> const_ref_cb = Bind(&Identity, ConstRef(n));
+  Callback<int()> copy_cb = Bind(&Identity, n);
+  Callback<int()> const_ref_cb = Bind(&Identity, ConstRef(n));
   EXPECT_EQ(n, copy_cb.Run());
   EXPECT_EQ(n, const_ref_cb.Run());
   n++;
   EXPECT_EQ(n - 1, copy_cb.Run());
   EXPECT_EQ(n, const_ref_cb.Run());
 
   int copies = 0;
   int assigns = 0;
   CopyCounter counter(&copies, &assigns);
-  Callback<int(void)> all_const_ref_cb =
+  Callback<int()> all_const_ref_cb =
       Bind(&GetCopies, ConstRef(counter));
   EXPECT_EQ(0, all_const_ref_cb.Run());
   EXPECT_EQ(0, copies);
   EXPECT_EQ(0, assigns);
 }
 
 TEST_F(BindTest, ScopedRefptr) {
   // BUG: The scoped_refptr should cause the only AddRef()/Release() pair. But
   // due to a bug in base::Bind(), there's an extra call when invoking the
   // callback.
   // https://code.google.com/p/chromium/issues/detail?id=251937
   EXPECT_CALL(has_ref_, AddRef()).Times(2);
   EXPECT_CALL(has_ref_, Release()).Times(2);
 
   const scoped_refptr<StrictMock<HasRef> > refptr(&has_ref_);
 
-  Callback<int(void)> scoped_refptr_const_ref_cb =
+  Callback<int()> scoped_refptr_const_ref_cb =
       Bind(&FunctionWithScopedRefptrFirstParam, base::ConstRef(refptr), 1);
   EXPECT_EQ(1, scoped_refptr_const_ref_cb.Run());
 }
 
 // Test Owned() support.
 TEST_F(BindTest, Owned) {
   int deletes = 0;
   DeleteCounter* counter = new DeleteCounter(&deletes);
 
   // If we don't capture, delete happens on Callback destruction/reset.
   // return the same value.
-  Callback<DeleteCounter*(void)> no_capture_cb =
+  Callback<DeleteCounter*()> no_capture_cb =
       Bind(&PolymorphicIdentity<DeleteCounter*>, Owned(counter));
   ASSERT_EQ(counter, no_capture_cb.Run());
   ASSERT_EQ(counter, no_capture_cb.Run());
   EXPECT_EQ(0, deletes);
   no_capture_cb.Reset();  // This should trigger a delete.
   EXPECT_EQ(1, deletes);
 
   deletes = 0;
   counter = new DeleteCounter(&deletes);
   base::Closure own_object_cb =
       Bind(&DeleteCounter::VoidMethod0, Owned(counter));
   own_object_cb.Run();
   EXPECT_EQ(0, deletes);
   own_object_cb.Reset();
   EXPECT_EQ(1, deletes);
 }
 
 // Passed() wrapper support.
 //   - Passed() can be constructed from a pointer to scoper.
 //   - Passed() can be constructed from a scoper rvalue.
 //   - Using Passed() gives Callback Ownership.
 //   - Ownership is transferred from Callback to callee on the first Run().
 //   - Callback supports unbound arguments.
 TEST_F(BindTest, ScopedPtr) {
   int deletes = 0;
 
   // Tests the Passed() function's support for pointers.
   scoped_ptr<DeleteCounter> ptr(new DeleteCounter(&deletes));
-  Callback<scoped_ptr<DeleteCounter>(void)> unused_callback =
+  Callback<scoped_ptr<DeleteCounter>()> unused_callback =
       Bind(&PassThru<scoped_ptr<DeleteCounter> >, Passed(&ptr));
   EXPECT_FALSE(ptr.get());
   EXPECT_EQ(0, deletes);
 
   // If we never invoke the Callback, it retains ownership and deletes.
   unused_callback.Reset();
   EXPECT_EQ(1, deletes);
 
   // Tests the Passed() function's support for rvalues.
   deletes = 0;
   DeleteCounter* counter = new DeleteCounter(&deletes);
-  Callback<scoped_ptr<DeleteCounter>(void)> callback =
+  Callback<scoped_ptr<DeleteCounter>()> callback =
       Bind(&PassThru<scoped_ptr<DeleteCounter> >,
            Passed(scoped_ptr<DeleteCounter>(counter)));
   EXPECT_FALSE(ptr.get());
   EXPECT_EQ(0, deletes);
 
   // Check that ownership can be transferred back out.
   scoped_ptr<DeleteCounter> result = callback.Run();
   ASSERT_EQ(counter, result.get());
   EXPECT_EQ(0, deletes);
 
@@ skipping 10 matching lines @@
       Bind(&PassThru<scoped_ptr<DeleteCounter> >);
   ptr.reset(new DeleteCounter(&deletes));
   cb_unbound.Run(std::move(ptr));
 }
 
 TEST_F(BindTest, UniquePtr) {
   int deletes = 0;
 
   // Tests the Passed() function's support for pointers.
   std::unique_ptr<DeleteCounter> ptr(new DeleteCounter(&deletes));
-  Callback<std::unique_ptr<DeleteCounter>(void)> unused_callback =
+  Callback<std::unique_ptr<DeleteCounter>()> unused_callback =
       Bind(&PassThru<std::unique_ptr<DeleteCounter>>, Passed(&ptr));
   EXPECT_FALSE(ptr.get());
   EXPECT_EQ(0, deletes);
 
   // If we never invoke the Callback, it retains ownership and deletes.
   unused_callback.Reset();
   EXPECT_EQ(1, deletes);
 
   // Tests the Passed() function's support for rvalues.
   deletes = 0;
   DeleteCounter* counter = new DeleteCounter(&deletes);
-  Callback<std::unique_ptr<DeleteCounter>(void)> callback =
+  Callback<std::unique_ptr<DeleteCounter>()> callback =
       Bind(&PassThru<std::unique_ptr<DeleteCounter>>,
            Passed(std::unique_ptr<DeleteCounter>(counter)));
   EXPECT_FALSE(ptr.get());
   EXPECT_EQ(0, deletes);
 
   // Check that ownership can be transferred back out.
   std::unique_ptr<DeleteCounter> result = callback.Run();
   ASSERT_EQ(counter, result.get());
   EXPECT_EQ(0, deletes);
 
@@ skipping 16 matching lines @@
 //   - Bound arguments are only copied once.
 //   - Forwarded arguments are only copied once.
 //   - Forwarded arguments with coercions are only copied twice (once for the
 //     coercion, and one for the final dispatch).
 TEST_F(BindTest, ArgumentCopies) {
   int copies = 0;
   int assigns = 0;
 
   CopyCounter counter(&copies, &assigns);
 
-  Callback<void(void)> copy_cb =
+  Callback<void()> copy_cb =
       Bind(&VoidPolymorphic<CopyCounter>::Run, counter);
   EXPECT_GE(1, copies);
   EXPECT_EQ(0, assigns);
 
   copies = 0;
   assigns = 0;
   Callback<void(CopyCounter)> forward_cb =
       Bind(&VoidPolymorphic<CopyCounter>::Run);
   forward_cb.Run(counter);
   EXPECT_GE(1, copies);
@@ skipping 21 matching lines @@
 }
 
 int __stdcall StdCallFunc(int n) {
   return n;
 }
 
 // Windows specific calling convention support.
 //   - Can bind a __fastcall function.
 //   - Can bind a __stdcall function.
 TEST_F(BindTest, WindowsCallingConventions) {
-  Callback<int(void)> fastcall_cb = Bind(&FastCallFunc, 1);
+  Callback<int()> fastcall_cb = Bind(&FastCallFunc, 1);
   EXPECT_EQ(1, fastcall_cb.Run());
 
-  Callback<int(void)> stdcall_cb = Bind(&StdCallFunc, 2);
+  Callback<int()> stdcall_cb = Bind(&StdCallFunc, 2);
   EXPECT_EQ(2, stdcall_cb.Run());
 }
 #endif
 
 #if (!defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)) && GTEST_HAS_DEATH_TEST
 
 // Test null callbacks cause a DCHECK.
 TEST(BindDeathTest, NullCallback) {
   base::Callback<void(int)> null_cb;
   ASSERT_TRUE(null_cb.is_null());
   EXPECT_DEATH(base::Bind(null_cb, 42), "");
 }
 
 #endif  // (!defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)) &&
         //     GTEST_HAS_DEATH_TEST
 
 }  // namespace
 }  // namespace base