"typedef Foo Bar" -> "using Bar = Foo" in //mojo/edk/....

mojo/edk/system/memory.h

 // Copyright 2013 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 MOJO_EDK_SYSTEM_MEMORY_H_
 #define MOJO_EDK_SYSTEM_MEMORY_H_
 
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>  // For |memcpy()|.
 
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "mojo/edk/system/system_impl_export.h"
 #include "mojo/public/c/system/macros.h"
 
 namespace mojo {
 namespace system {
 
 namespace internal {
 
 // Removes |const| from |T| (available as |remove_const<T>::type|):
 // TODO(vtl): Remove these once we have the C++11 |remove_const|.
 template <typename T>
 struct remove_const {
-  typedef T type;
+  using type = T;
 };
 template <typename T>
 struct remove_const<const T> {
-  typedef T type;
+  using type = T;
 };
 
 // Yields |(const) char| if |T| is |(const) void|, else |T|:
 template <typename T>
 struct VoidToChar {
-  typedef T type;
+  using type = T;
 };
 template <>
 struct VoidToChar<void> {
-  typedef char type;
+  using type = char;
 };
 template <>
 struct VoidToChar<const void> {
-  typedef const char type;
+  using type = const char;
 };
 
 // Checks (insofar as appropriate/possible) that |pointer| is a valid pointer to
 // a buffer of the given size and alignment (both in bytes).
 template <size_t size, size_t alignment>
 void MOJO_SYSTEM_IMPL_EXPORT CheckUserPointer(const void* pointer);
 
 // Checks (insofar as appropriate/possible) that |pointer| is a valid pointer to
 // a buffer of |count| elements of the given size and alignment (both in bytes).
 template <size_t size, size_t alignment>
@@ skipping 22 matching lines @@
 struct NullUserPointer {};
 
 // Represents a user pointer to a single |Type| (which must be POD), for Mojo
 // primitive parameters.
 //
 // Use a const |Type| for in parameters, and non-const |Type|s for out and
 // in-out parameters (in which case the |Put()| method is available).
 template <typename Type>
 class UserPointer {
  private:
-  typedef typename internal::VoidToChar<Type>::type NonVoidType;
+  using NonVoidType = typename internal::VoidToChar<Type>::type;
 
  public:
   // Instead of explicitly using these constructors, you can often use
   // |MakeUserPointer()| (or |NullUserPointer()| for null pointers). (The common
   // exception is when you have, e.g., a |char*| and want to get a
   // |UserPointer<void>|.)
   UserPointer() : pointer_(nullptr) {}
   explicit UserPointer(Type* pointer) : pointer_(pointer) {}
   // Allow implicit conversion from the "null user pointer".
   UserPointer(NullUserPointer) : pointer_(nullptr) {}
@@ skipping 138 matching lines @@
   //   MojoResult Core::GetFoos(UserPointer<uint32_t> foos,
   //                            uint32_t num_foos) {
   //     UserPointer<uint32_t>::Writer foos_writer(foos, num_foos);
   //     MojoResult rv = GetFoosImpl(foos.GetPointer(), num_foos);
   //     foos_writer.Commit();
   //     return rv;
   //   }
   //
   // TODO(vtl): Possibly, since we're not really being safe, we should just not
   // copy for Release builds.
-  typedef UserPointerReader<Type> Reader;
-  typedef UserPointerWriter<Type> Writer;
-  typedef UserPointerReaderWriter<Type> ReaderWriter;
+  using Reader = UserPointerReader<Type>;
+  using Writer = UserPointerWriter<Type>;
+  using ReaderWriter = UserPointerReaderWriter<Type>;
 
  private:
   friend class UserPointerReader<Type>;
   friend class UserPointerReader<const Type>;
   friend class UserPointerWriter<Type>;
   friend class UserPointerReaderWriter<Type>;
   template <class Options>
   friend class UserOptionsReader;
 
   Type* pointer_;
   // Allow copy and assignment.
 };
 
 // Provides a convenient way to make a |UserPointer<Type>|.
 template <typename Type>
 inline UserPointer<Type> MakeUserPointer(Type* pointer) {
   return UserPointer<Type>(pointer);
 }
 
 // Implementation of |UserPointer<Type>::Reader|.
 template <typename Type>
 class UserPointerReader {
  private:
-  typedef typename internal::remove_const<Type>::type TypeNoConst;
+  using TypeNoConst = typename internal::remove_const<Type>::type;
 
  public:
   // Note: If |count| is zero, |GetPointer()| will always return null.
   UserPointerReader(UserPointer<const Type> user_pointer, size_t count) {
     Init(user_pointer.pointer_, count, true);
   }
   UserPointerReader(UserPointer<TypeNoConst> user_pointer, size_t count) {
     Init(user_pointer.pointer_, count, true);
   }
 
@@ skipping 85 matching lines @@
   size_t count_;
   scoped_ptr<Type[]> buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(UserPointerReaderWriter);
 };
 
 }  // namespace system
 }  // namespace mojo
 
 #endif  // MOJO_EDK_SYSTEM_MEMORY_H_