Mojo: Convert OVERRIDE -> override in mojo/{embedder,system}.

mojo/system/raw_channel_win.cc

 // 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.
 
 #include "mojo/system/raw_channel.h"
 
 #include <windows.h>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
@@ skipping 57 matching lines @@
 
 base::LazyInstance<VistaOrHigherFunctions> g_vista_or_higher_functions =
     LAZY_INSTANCE_INITIALIZER;
 
 class RawChannelWin : public RawChannel {
  public:
   RawChannelWin(embedder::ScopedPlatformHandle handle);
   virtual ~RawChannelWin();
 
   // |RawChannel| public methods:
-  virtual size_t GetSerializedPlatformHandleSize() const OVERRIDE;
+  virtual size_t GetSerializedPlatformHandleSize() const override;
 
  private:
   // RawChannelIOHandler receives OS notifications for I/O completion. It must
   // be created on the I/O thread.
   //
   // It manages its own destruction. Destruction happens on the I/O thread when
   // all the following conditions are satisfied:
   //   - |DetachFromOwnerNoLock()| has been called;
   //   - there is no pending read;
   //   - there is no pending write.
@@ skipping 15 matching lines @@
     bool pending_write_no_lock() const;
     base::MessageLoopForIO::IOContext* write_context_no_lock();
     // Instructs the object to wait for an |OnIOCompleted()| notification.
     void OnPendingWriteStartedNoLock();
 
     // |base::MessageLoopForIO::IOHandler| implementation:
     // Must be called on the I/O thread. It could be called before or after
     // detached from the owner.
     virtual void OnIOCompleted(base::MessageLoopForIO::IOContext* context,
                                DWORD bytes_transferred,
-                               DWORD error) OVERRIDE;
+                               DWORD error) override;
 
     // Must be called on the I/O thread under |owner_->write_lock()|.
     // After this call, the owner must not make any further calls on this
     // object, and therefore the object is used on the I/O thread exclusively
     // (if it stays alive).
     void DetachFromOwnerNoLock(scoped_ptr<ReadBuffer> read_buffer,
                                scoped_ptr<WriteBuffer> write_buffer);
 
    private:
     virtual ~RawChannelIOHandler();
@@ skipping 28 matching lines @@
     // The following members must be used under |owner_->write_lock()| while the
     // object is still attached to the owner, and only on the I/O thread
     // afterwards.
     bool pending_write_;
     base::MessageLoopForIO::IOContext write_context_;
 
     DISALLOW_COPY_AND_ASSIGN(RawChannelIOHandler);
   };
 
   // |RawChannel| private methods:
-  virtual IOResult Read(size_t* bytes_read) OVERRIDE;
-  virtual IOResult ScheduleRead() OVERRIDE;
+  virtual IOResult Read(size_t* bytes_read) override;
+  virtual IOResult ScheduleRead() override;
   virtual embedder::ScopedPlatformHandleVectorPtr GetReadPlatformHandles(
       size_t num_platform_handles,
-      const void* platform_handle_table) OVERRIDE;
+      const void* platform_handle_table) override;
   virtual IOResult WriteNoLock(size_t* platform_handles_written,
-                               size_t* bytes_written) OVERRIDE;
-  virtual IOResult ScheduleWriteNoLock() OVERRIDE;
-  virtual bool OnInit() OVERRIDE;
+                               size_t* bytes_written) override;
+  virtual IOResult ScheduleWriteNoLock() override;
+  virtual bool OnInit() override;
   virtual void OnShutdownNoLock(scoped_ptr<ReadBuffer> read_buffer,
-                                scoped_ptr<WriteBuffer> write_buffer) OVERRIDE;
+                                scoped_ptr<WriteBuffer> write_buffer) override;
 
   // Passed to |io_handler_| during initialization.
   embedder::ScopedPlatformHandle handle_;
 
   RawChannelIOHandler* io_handler_;
 
   const bool skip_completion_port_on_success_;
 
   DISALLOW_COPY_AND_ASSIGN(RawChannelWin);
 };
@@ skipping 387 matching lines @@
 
 // Static factory method declared in raw_channel.h.
 // static
 scoped_ptr<RawChannel> RawChannel::Create(
     embedder::ScopedPlatformHandle handle) {
   return scoped_ptr<RawChannel>(new RawChannelWin(handle.Pass()));
 }
 
 }  // namespace system
 }  // namespace mojo