Mojo: MOJO_OVERRIDE -> override in mojo/.

mojo/public/cpp/bindings/tests/interface_ptr_unittest.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/public/cpp/bindings/error_handler.h"
 #include "mojo/public/cpp/environment/environment.h"
 #include "mojo/public/cpp/utility/run_loop.h"
 #include "mojo/public/interfaces/bindings/tests/math_calculator.mojom.h"
 #include "mojo/public/interfaces/bindings/tests/sample_service.mojom.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace test {
 namespace {
 
 class ErrorObserver : public ErrorHandler {
  public:
   ErrorObserver() : encountered_error_(false) {
   }
 
   bool encountered_error() const { return encountered_error_; }
 
-  virtual void OnConnectionError() MOJO_OVERRIDE {
-    encountered_error_ = true;
-  }
+  virtual void OnConnectionError() override { encountered_error_ = true; }
 
  private:
   bool encountered_error_;
 };
 
 class MathCalculatorImpl : public InterfaceImpl<math::Calculator> {
  public:
   virtual ~MathCalculatorImpl() {}
 
   MathCalculatorImpl()
       : total_(0.0),
         got_connection_(false) {
   }
 
-  virtual void OnConnectionEstablished() MOJO_OVERRIDE {
-    got_connection_ = true;
-  }
+  virtual void OnConnectionEstablished() override { got_connection_ = true; }
 
-  virtual void Clear() MOJO_OVERRIDE {
-    client()->Output(total_);
-  }
+  virtual void Clear() override { client()->Output(total_); }
 
-  virtual void Add(double value) MOJO_OVERRIDE {
+  virtual void Add(double value) override {
     total_ += value;
     client()->Output(total_);
   }
 
-  virtual void Multiply(double value) MOJO_OVERRIDE {
+  virtual void Multiply(double value) override {
     total_ *= value;
     client()->Output(total_);
   }
 
   bool got_connection() const {
     return got_connection_;
   }
 
  private:
   double total_;
@@ skipping 31 matching lines @@
   void Divide(double value) {
     calculator_->Multiply(1.0 / value);
   }
 
   double GetOutput() const {
     return output_;
   }
 
  private:
   // math::CalculatorUI implementation:
-  virtual void Output(double value) MOJO_OVERRIDE {
-    output_ = value;
-  }
+  virtual void Output(double value) override { output_ = value; }
 
   math::CalculatorPtr calculator_;
   double output_;
 };
 
 class SelfDestructingMathCalculatorUIImpl : public math::CalculatorUI {
  public:
   explicit SelfDestructingMathCalculatorUIImpl(math::CalculatorPtr calculator)
       : calculator_(calculator.Pass()),
         nesting_level_(0) {
     ++num_instances_;
     calculator_.set_client(this);
   }
 
   void BeginTest(bool nested) {
     nesting_level_ = nested ? 2 : 1;
     calculator_->Add(1.0);
   }
 
   static int num_instances() { return num_instances_; }
 
  private:
   virtual ~SelfDestructingMathCalculatorUIImpl() {
     --num_instances_;
   }
 
-  virtual void Output(double value) MOJO_OVERRIDE {
+  virtual void Output(double value) override {
     if (--nesting_level_ > 0) {
       // Add some more and wait for re-entrant call to Output!
       calculator_->Add(1.0);
       RunLoop::current()->RunUntilIdle();
     } else {
       delete this;
     }
   }
 
   math::CalculatorPtr calculator_;
   int nesting_level_;
   static int num_instances_;
 };
 
 // static
 int SelfDestructingMathCalculatorUIImpl::num_instances_ = 0;
 
 class ReentrantServiceImpl : public InterfaceImpl<sample::Service> {
  public:
   virtual ~ReentrantServiceImpl() {}
 
   ReentrantServiceImpl()
       : got_connection_(false), call_depth_(0), max_call_depth_(0) {}
 
-  virtual void OnConnectionEstablished() MOJO_OVERRIDE {
-    got_connection_ = true;
-  }
+  virtual void OnConnectionEstablished() override { got_connection_ = true; }
 
   bool got_connection() const {
     return got_connection_;
   }
 
   int max_call_depth() { return max_call_depth_; }
 
   virtual void Frobinate(sample::FooPtr foo,
                          sample::Service::BazOptions baz,
-                         sample::PortPtr port) MOJO_OVERRIDE {
+                         sample::PortPtr port) override {
     max_call_depth_ = std::max(++call_depth_, max_call_depth_);
     if (call_depth_ == 1) {
       EXPECT_TRUE(WaitForIncomingMethodCall());
     }
     call_depth_--;
   }
 
-  virtual void GetPort(mojo::InterfaceRequest<sample::Port> port)
-      MOJO_OVERRIDE {}
+  virtual void GetPort(mojo::InterfaceRequest<sample::Port> port) override {}
 
  private:
   bool got_connection_;
   int call_depth_;
   int max_call_depth_;
 };
 
 class InterfacePtrTest : public testing::Test {
  public:
   virtual ~InterfacePtrTest() {
@@ skipping 195 matching lines @@
                    sample::PortPtr());
 
   PumpMessages();
 
   EXPECT_EQ(2, impl->max_call_depth());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace mojo