Replace typedef with using for Callback/Bind related files

base/bind_internal.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 BASE_BIND_INTERNAL_H_
 #define BASE_BIND_INTERNAL_H_
 
 #include <type_traits>
 
 #include "base/bind_helpers.h"
@@ skipping 125 matching lines @@
 // IsMethod typedef is exposed.  The existence of this typedef (NOT the value)
 // marks that the wrapper should be considered a method wrapper.
 
 template <typename Functor>
 class RunnableAdapter;
 
 // Function.
 template <typename R, typename... Args>
 class RunnableAdapter<R(*)(Args...)> {
  public:
-  typedef R (RunType)(Args...);
+  // MSVC 2013 doesn't support Type Alias of function types.
+  // Revisit this after we update it to newer version.
+  typedef R RunType(Args...);
 
   explicit RunnableAdapter(R(*function)(Args...))
       : function_(function) {
   }
 
   R Run(typename CallbackParamTraits<Args>::ForwardType... args) {
     return function_(CallbackForward(args)...);
   }
 
  private:
   R (*function_)(Args...);
 };
 
 // Method.
 template <typename R, typename T, typename... Args>
 class RunnableAdapter<R(T::*)(Args...)> {
  public:
-  typedef R (RunType)(T*, Args...);
-  typedef true_type IsMethod;
+  // MSVC 2013 doesn't support Type Alias of function types.
+  // Revisit this after we update it to newer version.
+  typedef R RunType(T*, Args...);
+  using IsMethod = true_type;
 
   explicit RunnableAdapter(R(T::*method)(Args...))
       : method_(method) {
   }
 
   R Run(T* object, typename CallbackParamTraits<Args>::ForwardType... args) {
     return (object->*method_)(CallbackForward(args)...);
   }
 
  private:
   R (T::*method_)(Args...);
 };
 
 // Const Method.
 template <typename R, typename T, typename... Args>
 class RunnableAdapter<R(T::*)(Args...) const> {
  public:
-  typedef R (RunType)(const T*, Args...);
-  typedef true_type IsMethod;
+  using RunType = R(const T*, Args...);
+  using IsMethod = true_type;
 
   explicit RunnableAdapter(R(T::*method)(Args...) const)
       : method_(method) {
   }
 
   R Run(const T* object,
         typename CallbackParamTraits<Args>::ForwardType... args) {
     return (object->*method_)(CallbackForward(args)...);
   }
 
  private:
   R (T::*method_)(Args...) const;
 };
 
 
 // ForceVoidReturn<>
 //
 // Set of templates that support forcing the function return type to void.
 template <typename Sig>
 struct ForceVoidReturn;
 
 template <typename R, typename... Args>
 struct ForceVoidReturn<R(Args...)> {
-  typedef void(RunType)(Args...);
+  // MSVC 2013 doesn't support Type Alias of function types.
+  // Revisit this after we update it to newer version.
+  typedef void RunType(Args...);
 };
 
 
 // FunctorTraits<>
 //
 // See description at top of file.
 template <typename T>
 struct FunctorTraits {
-  typedef RunnableAdapter<T> RunnableType;
-  typedef typename RunnableType::RunType RunType;
+  using RunnableType = RunnableAdapter<T>;
+  using RunType = typename RunnableType::RunType;
 };
 
 template <typename T>
 struct FunctorTraits<IgnoreResultHelper<T>> {
-  typedef typename FunctorTraits<T>::RunnableType RunnableType;
-  typedef typename ForceVoidReturn<
-      typename RunnableType::RunType>::RunType RunType;
+  using RunnableType = typename FunctorTraits<T>::RunnableType;
+  using RunType =
+      typename ForceVoidReturn<typename RunnableType::RunType>::RunType;
 };
 
 template <typename T>
 struct FunctorTraits<Callback<T>> {
-  typedef Callback<T> RunnableType;
-  typedef typename Callback<T>::RunType RunType;
+  using RunnableType = Callback<T> ;
+  using RunType = typename Callback<T>::RunType;
 };
 
 
 // MakeRunnable<>
 //
 // Converts a passed in functor to a RunnableType using type inference.
 
 template <typename T>
 typename FunctorTraits<T>::RunnableType MakeRunnable(const T& t) {
   return RunnableAdapter<T>(t);
@@ skipping 166 matching lines @@
 
   static void Destroy(BindStateBase* self) {
     delete static_cast<BindState*>(self);
   }
 };
 
 }  // namespace internal
 }  // namespace base
 
 #endif  // BASE_BIND_INTERNAL_H_