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

mojo/edk/embedder/embedder.h

 // Copyright 2014 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_EMBEDDER_EMBEDDER_H_
 #define MOJO_EDK_EMBEDDER_EMBEDDER_H_
 
 #include <string>
 
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/task_runner.h"
 #include "mojo/edk/embedder/channel_info_forward.h"
 #include "mojo/edk/embedder/process_type.h"
 #include "mojo/edk/embedder/scoped_platform_handle.h"
 #include "mojo/edk/system/system_impl_export.h"
 #include "mojo/public/cpp/system/message_pipe.h"
 
 namespace mojo {
 namespace embedder {
 
 struct Configuration;
 class PlatformSupport;
 class ProcessDelegate;
-typedef void* SlaveInfo;
+using SlaveInfo = void*;
 
 // Basic configuration/initialization ------------------------------------------
 
 // |Init()| sets up the basic Mojo system environment, making the |Mojo...()|
 // functions available and functional. This is never shut down (except in tests
 // -- see test_embedder.h).
 
 // Returns the global configuration. In general, you should not need to change
 // the configuration, but if you do you must do it before calling |Init()|.
 MOJO_SYSTEM_IMPL_EXPORT Configuration* GetConfiguration();
@@ skipping 147 matching lines @@
 // respectively, and take the |ChannelInfo*| produced by the creation functions.
 
 // Creates a channel; must only be called from the I/O thread. |platform_handle|
 // should be a handle to a connected OS "pipe". Eventually (even on failure),
 // the "out" value |*channel_info| should be passed to |DestoryChannel()| to
 // tear down the channel. Returns a handle to the bootstrap message pipe.
 MOJO_SYSTEM_IMPL_EXPORT ScopedMessagePipeHandle
 CreateChannelOnIOThread(ScopedPlatformHandle platform_handle,
                         ChannelInfo** channel_info);
 
-typedef base::Callback<void(ChannelInfo*)> DidCreateChannelCallback;
+using DidCreateChannelCallback = base::Callback<void(ChannelInfo*)>;
 // Creates a channel asynchronously; may be called from any thread.
 // |platform_handle| should be a handle to a connected OS "pipe".
 // |io_thread_task_runner| should be the |TaskRunner| for the I/O thread.
 // |callback| should be the callback to call with the |ChannelInfo*|, which
 // should eventually be passed to |DestroyChannel()| to tear down the channel;
 // the callback will be called using |callback_thread_task_runner| if that is
 // non-null, or otherwise it will be called using |io_thread_task_runner|.
 // Returns a handle to the bootstrap message pipe.
 MOJO_SYSTEM_IMPL_EXPORT ScopedMessagePipeHandle
 CreateChannel(ScopedPlatformHandle platform_handle,
               scoped_refptr<base::TaskRunner> io_thread_task_runner,
               const DidCreateChannelCallback& callback,
               scoped_refptr<base::TaskRunner> callback_thread_task_runner);
 
 // Destroys a channel that was created using |CreateChannel()| (or
 // |CreateChannelOnIOThread()|); must be called from the channel's I'O thread.
 // |channel_info| should be the value provided to the callback to
 // |CreateChannel()| (or returned by |CreateChannelOnIOThread()|). Completes
 // synchronously (and posts no tasks).
 MOJO_SYSTEM_IMPL_EXPORT void DestroyChannelOnIOThread(
     ChannelInfo* channel_info);
 
-typedef base::Closure DidDestroyChannelCallback;
+using DidDestroyChannelCallback = base::Closure;
 // Like |DestroyChannelOnIOThread()|, but asynchronous and may be called from
 // any thread. The callback will be called using |callback_thread_task_runner|
 // if that is non-null, or otherwise it will be called on the "channel thread".
 // The "channel thread" must remain alive and continue to process tasks until
 // the callback has been executed.
 MOJO_SYSTEM_IMPL_EXPORT void DestroyChannel(
     ChannelInfo* channel_info,
     const DidDestroyChannelCallback& callback,
     scoped_refptr<base::TaskRunner> callback_thread_task_runner);
 
 // Inform the channel that it will soon be destroyed (doing so is optional).
 // This may be called from any thread, but the caller must ensure that this is
 // called before |DestroyChannel()|.
 MOJO_SYSTEM_IMPL_EXPORT void WillDestroyChannelSoon(ChannelInfo* channel_info);
 
 }  // namespace embedder
 }  // namespace mojo
 
 #endif  // MOJO_EDK_EMBEDDER_EMBEDDER_H_