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

mojo/system/raw_channel_unittest.cc

 // 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.
 
 #include "mojo/system/raw_channel.h"
 
 #include <stdint.h>
 
 #include <vector>
 
@@ skipping 57 matching lines @@
   return write_size == message->main_buffer_size();
 }
 
 // -----------------------------------------------------------------------------
 
 class RawChannelTest : public testing::Test {
  public:
   RawChannelTest() : io_thread_(base::TestIOThread::kManualStart) {}
   virtual ~RawChannelTest() {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     embedder::PlatformChannelPair channel_pair;
     handles[0] = channel_pair.PassServerHandle();
     handles[1] = channel_pair.PassClientHandle();
     io_thread_.Start();
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     io_thread_.Stop();
     handles[0].reset();
     handles[1].reset();
   }
 
  protected:
   base::TestIOThread* io_thread() { return &io_thread_; }
 
   embedder::ScopedPlatformHandle handles[2];
 
  private:
   base::TestIOThread io_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(RawChannelTest);
 };
 
 // RawChannelTest.WriteMessage -------------------------------------------------
 
 class WriteOnlyRawChannelDelegate : public RawChannel::Delegate {
  public:
   WriteOnlyRawChannelDelegate() {}
   virtual ~WriteOnlyRawChannelDelegate() {}
 
   // |RawChannel::Delegate| implementation:
   virtual void OnReadMessage(
       const MessageInTransit::View& /*message_view*/,
-      embedder::ScopedPlatformHandleVectorPtr /*platform_handles*/) OVERRIDE {
+      embedder::ScopedPlatformHandleVectorPtr /*platform_handles*/) override {
     CHECK(false);  // Should not get called.
   }
-  virtual void OnError(Error error) OVERRIDE {
+  virtual void OnError(Error error) override {
     // We'll get a read (shutdown) error when the connection is closed.
     CHECK_EQ(error, ERROR_READ_SHUTDOWN);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(WriteOnlyRawChannelDelegate);
 };
 
 static const int64_t kMessageReaderSleepMs = 1;
 static const size_t kMessageReaderMaxPollIterations = 3000;
@@ skipping 92 matching lines @@
 // RawChannelTest.OnReadMessage ------------------------------------------------
 
 class ReadCheckerRawChannelDelegate : public RawChannel::Delegate {
  public:
   ReadCheckerRawChannelDelegate() : done_event_(false, false), position_(0) {}
   virtual ~ReadCheckerRawChannelDelegate() {}
 
   // |RawChannel::Delegate| implementation (called on the I/O thread):
   virtual void OnReadMessage(
       const MessageInTransit::View& message_view,
-      embedder::ScopedPlatformHandleVectorPtr platform_handles) OVERRIDE {
+      embedder::ScopedPlatformHandleVectorPtr platform_handles) override {
     EXPECT_FALSE(platform_handles);
 
     size_t position;
     size_t expected_size;
     bool should_signal = false;
     {
       base::AutoLock locker(lock_);
       CHECK_LT(position_, expected_sizes_.size());
       position = position_;
       expected_size = expected_sizes_[position];
       position_++;
       if (position_ >= expected_sizes_.size())
         should_signal = true;
     }
 
     EXPECT_EQ(expected_size, message_view.num_bytes()) << position;
     if (message_view.num_bytes() == expected_size) {
       EXPECT_TRUE(
           CheckMessageData(message_view.bytes(), message_view.num_bytes()))
           << position;
     }
 
     if (should_signal)
       done_event_.Signal();
   }
-  virtual void OnError(Error error) OVERRIDE {
+  virtual void OnError(Error error) override {
     // We'll get a read (shutdown) error when the connection is closed.
     CHECK_EQ(error, ERROR_READ_SHUTDOWN);
   }
 
   // Waits for all the messages (of sizes |expected_sizes_|) to be seen.
   void Wait() { done_event_.Wait(); }
 
   void SetExpectedSizes(const std::vector<uint32_t>& expected_sizes) {
     base::AutoLock locker(lock_);
     CHECK_EQ(position_, expected_sizes_.size());
@@ skipping 47 matching lines @@
 class RawChannelWriterThread : public base::SimpleThread {
  public:
   RawChannelWriterThread(RawChannel* raw_channel, size_t write_count)
       : base::SimpleThread("raw_channel_writer_thread"),
         raw_channel_(raw_channel),
         left_to_write_(write_count) {}
 
   virtual ~RawChannelWriterThread() { Join(); }
 
  private:
-  virtual void Run() OVERRIDE {
+  virtual void Run() override {
     static const int kMaxRandomMessageSize = 25000;
 
     while (left_to_write_-- > 0) {
       EXPECT_TRUE(raw_channel_->WriteMessage(MakeTestMessage(
           static_cast<uint32_t>(base::RandInt(1, kMaxRandomMessageSize)))));
     }
   }
 
   RawChannel* const raw_channel_;
   size_t left_to_write_;
 
   DISALLOW_COPY_AND_ASSIGN(RawChannelWriterThread);
 };
 
 class ReadCountdownRawChannelDelegate : public RawChannel::Delegate {
  public:
   explicit ReadCountdownRawChannelDelegate(size_t expected_count)
       : done_event_(false, false), expected_count_(expected_count), count_(0) {}
   virtual ~ReadCountdownRawChannelDelegate() {}
 
   // |RawChannel::Delegate| implementation (called on the I/O thread):
   virtual void OnReadMessage(
       const MessageInTransit::View& message_view,
-      embedder::ScopedPlatformHandleVectorPtr platform_handles) OVERRIDE {
+      embedder::ScopedPlatformHandleVectorPtr platform_handles) override {
     EXPECT_FALSE(platform_handles);
 
     EXPECT_LT(count_, expected_count_);
     count_++;
 
     EXPECT_TRUE(
         CheckMessageData(message_view.bytes(), message_view.num_bytes()));
 
     if (count_ >= expected_count_)
       done_event_.Signal();
   }
-  virtual void OnError(Error error) OVERRIDE {
+  virtual void OnError(Error error) override {
     // We'll get a read (shutdown) error when the connection is closed.
     CHECK_EQ(error, ERROR_READ_SHUTDOWN);
   }
 
   // Waits for all the messages to have been seen.
   void Wait() { done_event_.Wait(); }
 
  private:
   base::WaitableEvent done_event_;
   size_t expected_count_;
@@ skipping 56 matching lines @@
                                    bool expect_read_error,
                                    bool expect_write_error)
       : ReadCountdownRawChannelDelegate(expected_read_count),
         got_read_error_event_(false, false),
         got_write_error_event_(false, false),
         expecting_read_error_(expect_read_error),
         expecting_write_error_(expect_write_error) {}
 
   virtual ~ErrorRecordingRawChannelDelegate() {}
 
-  virtual void OnError(Error error) OVERRIDE {
+  virtual void OnError(Error error) override {
     switch (error) {
       case ERROR_READ_SHUTDOWN:
         ASSERT_TRUE(expecting_read_error_);
         expecting_read_error_ = false;
         got_read_error_event_.Signal();
         break;
       case ERROR_READ_BROKEN:
         // TODO(vtl): Test broken connections.
         CHECK(false);
         break;
@@ skipping 114 matching lines @@
  public:
   explicit ShutdownOnReadMessageRawChannelDelegate(RawChannel* raw_channel)
       : raw_channel_(raw_channel),
         done_event_(false, false),
         did_shutdown_(false) {}
   virtual ~ShutdownOnReadMessageRawChannelDelegate() {}
 
   // |RawChannel::Delegate| implementation (called on the I/O thread):
   virtual void OnReadMessage(
       const MessageInTransit::View& message_view,
-      embedder::ScopedPlatformHandleVectorPtr platform_handles) OVERRIDE {
+      embedder::ScopedPlatformHandleVectorPtr platform_handles) override {
     EXPECT_FALSE(platform_handles);
     EXPECT_FALSE(did_shutdown_);
     EXPECT_TRUE(
         CheckMessageData(message_view.bytes(), message_view.num_bytes()));
     raw_channel_->Shutdown();
     did_shutdown_ = true;
     done_event_.Signal();
   }
-  virtual void OnError(Error /*error*/) OVERRIDE {
+  virtual void OnError(Error /*error*/) override {
     CHECK(false);  // Should not get called.
   }
 
   // Waits for shutdown.
   void Wait() {
     done_event_.Wait();
     EXPECT_TRUE(did_shutdown_);
   }
 
  private:
@@ skipping 27 matching lines @@
                                     Error shutdown_on_error_type)
       : raw_channel_(raw_channel),
         shutdown_on_error_type_(shutdown_on_error_type),
         done_event_(false, false),
         did_shutdown_(false) {}
   virtual ~ShutdownOnErrorRawChannelDelegate() {}
 
   // |RawChannel::Delegate| implementation (called on the I/O thread):
   virtual void OnReadMessage(
       const MessageInTransit::View& /*message_view*/,
-      embedder::ScopedPlatformHandleVectorPtr /*platform_handles*/) OVERRIDE {
+      embedder::ScopedPlatformHandleVectorPtr /*platform_handles*/) override {
     CHECK(false);  // Should not get called.
   }
-  virtual void OnError(Error error) OVERRIDE {
+  virtual void OnError(Error error) override {
     EXPECT_FALSE(did_shutdown_);
     if (error != shutdown_on_error_type_)
       return;
     raw_channel_->Shutdown();
     did_shutdown_ = true;
     done_event_.Signal();
   }
 
   // Waits for shutdown.
   void Wait() {
@@ skipping 38 matching lines @@
 
   EXPECT_FALSE(rc->WriteMessage(MakeTestMessage(1)));
 
   // Wait for the delegate, which will shut the |RawChannel| down.
   delegate.Wait();
 }
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo