Replacing the OVERRIDE with override in tools folder

This step is a giant search and replace for OVERRIDE to
replace them with their lowercase versions.

BUG=417463

Review URL: https://codereview.chromium.org/631653002

Cr-Commit-Position: refs/heads/master@{#300594}

tools/android/forwarder2/device_forwarder_main.cc

@@ -68,7 +68,7 @@ class ServerDelegate : public Daemon::ServerDelegate {
   }
 
   // Daemon::ServerDelegate:
-  virtual void Init() OVERRIDE {
+  virtual void Init() override {
     DCHECK(!g_notifier);
     g_notifier = new forwarder2::PipeNotifier();
     signal(SIGTERM, KillHandler);
@@ -77,7 +77,7 @@ class ServerDelegate : public Daemon::ServerDelegate {
     controller_thread_->Start();
   }
 
-  virtual void OnClientConnected(scoped_ptr<Socket> client_socket) OVERRIDE {
+  virtual void OnClientConnected(scoped_ptr<Socket> client_socket) override {
     if (initialized_) {
       client_socket->WriteString("OK");
       return;
@@ -119,7 +119,7 @@ class ClientDelegate : public Daemon::ClientDelegate {
   bool has_failed() const { return has_failed_; }
 
   // Daemon::ClientDelegate:
-  virtual void OnDaemonReady(Socket* daemon_socket) OVERRIDE {
+  virtual void OnDaemonReady(Socket* daemon_socket) override {
     char buf[kBufSize];
     const int bytes_read = daemon_socket->Read(
         buf, sizeof(buf) - 1 /* leave space for null terminator */);

tools/android/forwarder2/host_forwarder_main.cc

@@ -311,7 +311,7 @@ class ServerDelegate : public Daemon::ServerDelegate {
   }
 
   // Daemon::ServerDelegate:
-  virtual void Init() OVERRIDE {
+  virtual void Init() override {
     LOG(INFO) << "Starting host process daemon (pid=" << getpid() << ")";
     DCHECK(!g_notifier);
     g_notifier = new PipeNotifier();
@@ -319,7 +319,7 @@ class ServerDelegate : public Daemon::ServerDelegate {
     signal(SIGINT, KillHandler);
   }
 
-  virtual void OnClientConnected(scoped_ptr<Socket> client_socket) OVERRIDE {
+  virtual void OnClientConnected(scoped_ptr<Socket> client_socket) override {
     char buf[kBufSize];
     const int bytes_read = client_socket->Read(buf, sizeof(buf));
     if (bytes_read <= 0) {
@@ -362,7 +362,7 @@ class ClientDelegate : public Daemon::ClientDelegate {
   bool has_failed() const { return has_failed_; }
 
   // Daemon::ClientDelegate:
-  virtual void OnDaemonReady(Socket* daemon_socket) OVERRIDE {
+  virtual void OnDaemonReady(Socket* daemon_socket) override {
     // Send the forward command to the daemon.
     CHECK_EQ(command_pickle_.size(),
              daemon_socket->WriteNumBytes(command_pickle_.data(),

tools/android/heap_profiler/heap_profiler_unittest.cc

@@ -14,9 +14,9 @@ namespace {
 
 class HeapProfilerTest : public testing::Test {
  public:
-  virtual void SetUp() OVERRIDE { heap_profiler_init(&stats_); }
+  virtual void SetUp() override { heap_profiler_init(&stats_); }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     CheckAllocVsStacktaceConsistency();
     heap_profiler_cleanup();
   }

tools/gn/action_target_generator.h

@@ -19,7 +19,7 @@ class ActionTargetGenerator : public TargetGenerator {
   virtual ~ActionTargetGenerator();
 
  protected:
-  virtual void DoRun() OVERRIDE;
+  virtual void DoRun() override;
 
  private:
   bool FillScript();

tools/gn/binary_target_generator.h

@@ -20,7 +20,7 @@ class BinaryTargetGenerator : public TargetGenerator {
   virtual ~BinaryTargetGenerator();
 
  protected:
-  virtual void DoRun() OVERRIDE;
+  virtual void DoRun() override;
 
  private:
   bool FillCheckIncludes();

tools/gn/builder_unittest.cc

@@ -19,16 +19,16 @@ class MockLoader : public Loader {
   // Loader implementation:
   virtual void Load(const SourceFile& file,
                     const LocationRange& origin,
-                    const Label& toolchain_name) OVERRIDE {
+                    const Label& toolchain_name) override {
     files_.push_back(file);
   }
-  virtual void ToolchainLoaded(const Toolchain* toolchain) OVERRIDE {
+  virtual void ToolchainLoaded(const Toolchain* toolchain) override {
   }
-  virtual Label GetDefaultToolchain() const OVERRIDE {
+  virtual Label GetDefaultToolchain() const override {
     return Label();
   }
   virtual const Settings* GetToolchainSettings(
-      const Label& label) const OVERRIDE {
+      const Label& label) const override {
     return NULL;
   }
 

tools/gn/config.h

@@ -15,8 +15,8 @@ class Config : public Item {
   Config(const Settings* settings, const Label& label);
   virtual ~Config();
 
-  virtual Config* AsConfig() OVERRIDE;
-  virtual const Config* AsConfig() const OVERRIDE;
+  virtual Config* AsConfig() override;
+  virtual const Config* AsConfig() const override;
 
   ConfigValues& config_values() { return config_values_; }
   const ConfigValues& config_values() const { return config_values_; }

tools/gn/copy_target_generator.h

@@ -18,7 +18,7 @@ class CopyTargetGenerator : public TargetGenerator {
   virtual ~CopyTargetGenerator();
 
  protected:
-  virtual void DoRun() OVERRIDE;
+  virtual void DoRun() override;
 
  private:
   void FillDestDir();

tools/gn/group_target_generator.h

@@ -18,7 +18,7 @@ class GroupTargetGenerator : public TargetGenerator {
   virtual ~GroupTargetGenerator();
 
  protected:
-  virtual void DoRun() OVERRIDE;
+  virtual void DoRun() override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(GroupTargetGenerator);

tools/gn/loader.h

@@ -84,11 +84,11 @@ class LoaderImpl : public Loader {
   // Loader implementation.
   virtual void Load(const SourceFile& file,
                     const LocationRange& origin,
-                    const Label& toolchain_name) OVERRIDE;
-  virtual void ToolchainLoaded(const Toolchain* toolchain) OVERRIDE;
-  virtual Label GetDefaultToolchain() const OVERRIDE;
+                    const Label& toolchain_name) override;
+  virtual void ToolchainLoaded(const Toolchain* toolchain) override;
+  virtual Label GetDefaultToolchain() const override;
   virtual const Settings* GetToolchainSettings(
-      const Label& label) const OVERRIDE;
+      const Label& label) const override;
 
   // Sets the message loop corresponding to the main thread. By default this
   // class will use the thread active during construction, but there is not

tools/gn/ninja_action_target_writer.h

@@ -19,7 +19,7 @@ class NinjaActionTargetWriter : public NinjaTargetWriter {
   NinjaActionTargetWriter(const Target* target, std::ostream& out);
   virtual ~NinjaActionTargetWriter();
 
-  virtual void Run() OVERRIDE;
+  virtual void Run() override;
 
  private:
   FRIEND_TEST_ALL_PREFIXES(NinjaActionTargetWriter,

tools/gn/ninja_binary_target_writer.h

@@ -20,7 +20,7 @@ class NinjaBinaryTargetWriter : public NinjaTargetWriter {
   NinjaBinaryTargetWriter(const Target* target, std::ostream& out);
   virtual ~NinjaBinaryTargetWriter();
 
-  virtual void Run() OVERRIDE;
+  virtual void Run() override;
 
  private:
   typedef std::set<OutputFile> OutputFileSet;

tools/gn/ninja_copy_target_writer.h

@@ -16,7 +16,7 @@ class NinjaCopyTargetWriter : public NinjaTargetWriter {
   NinjaCopyTargetWriter(const Target* target, std::ostream& out);
   virtual ~NinjaCopyTargetWriter();
 
-  virtual void Run() OVERRIDE;
+  virtual void Run() override;
 
  private:
   // Writes the rules top copy the file(s), putting the computed output file

tools/gn/ninja_group_target_writer.h

@@ -14,7 +14,7 @@ class NinjaGroupTargetWriter : public NinjaTargetWriter {
   NinjaGroupTargetWriter(const Target* target, std::ostream& out);
   virtual ~NinjaGroupTargetWriter();
 
-  virtual void Run() OVERRIDE;
+  virtual void Run() override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(NinjaGroupTargetWriter);

tools/gn/ninja_target_writer_unittest.cc

@@ -19,7 +19,7 @@ class TestingNinjaTargetWriter : public NinjaTargetWriter {
       : NinjaTargetWriter(target, out) {
   }
 
-  virtual void Run() OVERRIDE {}
+  virtual void Run() override {}
 
   // Make this public so the test can call it.
   OutputFile WriteInputDepsStampAndGetDep(

tools/gn/parse_tree.h

@@ -139,13 +139,13 @@ class AccessorNode : public ParseNode {
   AccessorNode();
   virtual ~AccessorNode();
 
-  virtual const AccessorNode* AsAccessor() const OVERRIDE;
-  virtual Value Execute(Scope* scope, Err* err) const OVERRIDE;
-  virtual LocationRange GetRange() const OVERRIDE;
+  virtual const AccessorNode* AsAccessor() const override;
+  virtual Value Execute(Scope* scope, Err* err) const override;
+  virtual LocationRange GetRange() const override;
   virtual Err MakeErrorDescribing(
       const std::string& msg,
-      const std::string& help = std::string()) const OVERRIDE;
-  virtual void Print(std::ostream& out, int indent) const OVERRIDE;
+      const std::string& help = std::string()) const override;
+  virtual void Print(std::ostream& out, int indent) const override;
 
   // Base is the thing on the left of the [] or dot, currently always required
   // to be an identifier token.
@@ -182,13 +182,13 @@ class BinaryOpNode : public ParseNode {
   BinaryOpNode();
   virtual ~BinaryOpNode();
 
-  virtual const BinaryOpNode* AsBinaryOp() const OVERRIDE;
-  virtual Value Execute(Scope* scope, Err* err) const OVERRIDE;
-  virtual LocationRange GetRange() const OVERRIDE;
+  virtual const BinaryOpNode* AsBinaryOp() const override;
+  virtual Value Execute(Scope* scope, Err* err) const override;
+  virtual LocationRange GetRange() const override;
   virtual Err MakeErrorDescribing(
       const std::string& msg,
-      const std::string& help = std::string()) const OVERRIDE;
-  virtual void Print(std::ostream& out, int indent) const OVERRIDE;
+      const std::string& help = std::string()) const override;
+  virtual void Print(std::ostream& out, int indent) const override;
 
   const Token& op() const { return op_; }
   void set_op(const Token& t) { op_ = t; }
@@ -219,13 +219,13 @@ class BlockNode : public ParseNode {
   explicit BlockNode(bool has_scope);
   virtual ~BlockNode();
 
-  virtual const BlockNode* AsBlock() const OVERRIDE;
-  virtual Value Execute(Scope* scope, Err* err) const OVERRIDE;
-  virtual LocationRange GetRange() const OVERRIDE;
+  virtual const BlockNode* AsBlock() const override;
+  virtual Value Execute(Scope* scope, Err* err) const override;
+  virtual LocationRange GetRange() const override;
   virtual Err MakeErrorDescribing(
       const std::string& msg,
-      const std::string& help = std::string()) const OVERRIDE;
-  virtual void Print(std::ostream& out, int indent) const OVERRIDE;
+      const std::string& help = std::string()) const override;
+  virtual void Print(std::ostream& out, int indent) const override;
 
   void set_begin_token(const Token& t) { begin_token_ = t; }
   void set_end(scoped_ptr<EndNode> e) { end_ = e.Pass(); }
@@ -260,13 +260,13 @@ class ConditionNode : public ParseNode {
   ConditionNode();
   virtual ~ConditionNode();
 
-  virtual const ConditionNode* AsConditionNode() const OVERRIDE;
-  virtual Value Execute(Scope* scope, Err* err) const OVERRIDE;
-  virtual LocationRange GetRange() const OVERRIDE;
+  virtual const ConditionNode* AsConditionNode() const override;
+  virtual Value Execute(Scope* scope, Err* err) const override;
+  virtual LocationRange GetRange() const override;
   virtual Err MakeErrorDescribing(
       const std::string& msg,
-      const std::string& help = std::string()) const OVERRIDE;
-  virtual void Print(std::ostream& out, int indent) const OVERRIDE;
+      const std::string& help = std::string()) const override;
+  virtual void Print(std::ostream& out, int indent) const override;
 
   void set_if_token(const Token& token) { if_token_ = token; }
 
@@ -305,13 +305,13 @@ class FunctionCallNode : public ParseNode {
   FunctionCallNode();
   virtual ~FunctionCallNode();
 
-  virtual const FunctionCallNode* AsFunctionCall() const OVERRIDE;
-  virtual Value Execute(Scope* scope, Err* err) const OVERRIDE;
-  virtual LocationRange GetRange() const OVERRIDE;
+  virtual const FunctionCallNode* AsFunctionCall() const override;
+  virtual Value Execute(Scope* scope, Err* err) const override;
+  virtual LocationRange GetRange() const override;
   virtual Err MakeErrorDescribing(
       const std::string& msg,
-      const std::string& help = std::string()) const OVERRIDE;
-  virtual void Print(std::ostream& out, int indent) const OVERRIDE;
+      const std::string& help = std::string()) const override;
+  virtual void Print(std::ostream& out, int indent) const override;
 
   const Token& function() const { return function_; }
   void set_function(Token t) { function_ = t; }
@@ -338,13 +338,13 @@ class IdentifierNode : public ParseNode {
   IdentifierNode(const Token& token);
   virtual ~IdentifierNode();
 
-  virtual const IdentifierNode* AsIdentifier() const OVERRIDE;
-  virtual Value Execute(Scope* scope, Err* err) const OVERRIDE;
-  virtual LocationRange GetRange() const OVERRIDE;
+  virtual const IdentifierNode* AsIdentifier() const override;
+  virtual Value Execute(Scope* scope, Err* err) const override;
+  virtual LocationRange GetRange() const override;
   virtual Err MakeErrorDescribing(
       const std::string& msg,
-      const std::string& help = std::string()) const OVERRIDE;
-  virtual void Print(std::ostream& out, int indent) const OVERRIDE;
+      const std::string& help = std::string()) const override;
+  virtual void Print(std::ostream& out, int indent) const override;
 
   const Token& value() const { return value_; }
   void set_value(const Token& t) { value_ = t; }
@@ -362,13 +362,13 @@ class ListNode : public ParseNode {
   ListNode();
   virtual ~ListNode();
 
-  virtual const ListNode* AsList() const OVERRIDE;
-  virtual Value Execute(Scope* scope, Err* err) const OVERRIDE;
-  virtual LocationRange GetRange() const OVERRIDE;
+  virtual const ListNode* AsList() const override;
+  virtual Value Execute(Scope* scope, Err* err) const override;
+  virtual LocationRange GetRange() const override;
   virtual Err MakeErrorDescribing(
       const std::string& msg,
-      const std::string& help = std::string()) const OVERRIDE;
-  virtual void Print(std::ostream& out, int indent) const OVERRIDE;
+      const std::string& help = std::string()) const override;
+  virtual void Print(std::ostream& out, int indent) const override;
 
   void set_begin_token(const Token& t) { begin_token_ = t; }
   void set_end(scoped_ptr<EndNode> e) { end_ = e.Pass(); }
@@ -399,13 +399,13 @@ class LiteralNode : public ParseNode {
   LiteralNode(const Token& token);
   virtual ~LiteralNode();
 
-  virtual const LiteralNode* AsLiteral() const OVERRIDE;
-  virtual Value Execute(Scope* scope, Err* err) const OVERRIDE;
-  virtual LocationRange GetRange() const OVERRIDE;
+  virtual const LiteralNode* AsLiteral() const override;
+  virtual Value Execute(Scope* scope, Err* err) const override;
+  virtual LocationRange GetRange() const override;
   virtual Err MakeErrorDescribing(
       const std::string& msg,
-      const std::string& help = std::string()) const OVERRIDE;
-  virtual void Print(std::ostream& out, int indent) const OVERRIDE;
+      const std::string& help = std::string()) const override;
+  virtual void Print(std::ostream& out, int indent) const override;
 
   const Token& value() const { return value_; }
   void set_value(const Token& t) { value_ = t; }
@@ -423,13 +423,13 @@ class UnaryOpNode : public ParseNode {
   UnaryOpNode();
   virtual ~UnaryOpNode();
 
-  virtual const UnaryOpNode* AsUnaryOp() const OVERRIDE;
-  virtual Value Execute(Scope* scope, Err* err) const OVERRIDE;
-  virtual LocationRange GetRange() const OVERRIDE;
+  virtual const UnaryOpNode* AsUnaryOp() const override;
+  virtual Value Execute(Scope* scope, Err* err) const override;
+  virtual LocationRange GetRange() const override;
   virtual Err MakeErrorDescribing(
       const std::string& msg,
-      const std::string& help = std::string()) const OVERRIDE;
-  virtual void Print(std::ostream& out, int indent) const OVERRIDE;
+      const std::string& help = std::string()) const override;
+  virtual void Print(std::ostream& out, int indent) const override;
 
   const Token& op() const { return op_; }
   void set_op(const Token& t) { op_ = t; }
@@ -458,13 +458,13 @@ class BlockCommentNode : public ParseNode {
   BlockCommentNode();
   virtual ~BlockCommentNode();
 
-  virtual const BlockCommentNode* AsBlockComment() const OVERRIDE;
-  virtual Value Execute(Scope* scope, Err* err) const OVERRIDE;
-  virtual LocationRange GetRange() const OVERRIDE;
+  virtual const BlockCommentNode* AsBlockComment() const override;
+  virtual Value Execute(Scope* scope, Err* err) const override;
+  virtual LocationRange GetRange() const override;
   virtual Err MakeErrorDescribing(
       const std::string& msg,
-      const std::string& help = std::string()) const OVERRIDE;
-  virtual void Print(std::ostream& out, int indent) const OVERRIDE;
+      const std::string& help = std::string()) const override;
+  virtual void Print(std::ostream& out, int indent) const override;
 
   const Token& comment() const { return comment_; }
   void set_comment(const Token& t) { comment_ = t; }
@@ -486,13 +486,13 @@ class EndNode : public ParseNode {
   EndNode(const Token& token);
   virtual ~EndNode();
 
-  virtual const EndNode* AsEnd() const OVERRIDE;
-  virtual Value Execute(Scope* scope, Err* err) const OVERRIDE;
-  virtual LocationRange GetRange() const OVERRIDE;
+  virtual const EndNode* AsEnd() const override;
+  virtual Value Execute(Scope* scope, Err* err) const override;
+  virtual LocationRange GetRange() const override;
   virtual Err MakeErrorDescribing(
       const std::string& msg,
-      const std::string& help = std::string()) const OVERRIDE;
-  virtual void Print(std::ostream& out, int indent) const OVERRIDE;
+      const std::string& help = std::string()) const override;
+  virtual void Print(std::ostream& out, int indent) const override;
 
   const Token& value() const { return value_; }
   void set_value(const Token& t) { value_ = t; }

tools/gn/scope_per_file_provider.h

@@ -22,7 +22,7 @@ class ScopePerFileProvider : public Scope::ProgrammaticProvider {
 
   // ProgrammaticProvider implementation.
   virtual const Value* GetProgrammaticValue(
-      const base::StringPiece& ident) OVERRIDE;
+      const base::StringPiece& ident) override;
 
  private:
   const Value* GetCurrentToolchain();

tools/gn/setup.h

@@ -114,7 +114,7 @@ class Setup : public CommonSetup {
 
   Scheduler& scheduler() { return scheduler_; }
 
-  virtual Scheduler* GetScheduler() OVERRIDE;
+  virtual Scheduler* GetScheduler() override;
 
   // Returns the file used to store the build arguments. Note that the path
   // might not exist.
@@ -209,7 +209,7 @@ class DependentSetup : public CommonSetup {
   void RunPreMessageLoop();
   bool RunPostMessageLoop();
 
-  virtual Scheduler* GetScheduler() OVERRIDE;
+  virtual Scheduler* GetScheduler() override;
 
  private:
   Scheduler* scheduler_;

tools/gn/target.h

@@ -58,9 +58,9 @@ class Target : public Item {
   static const char* GetStringForOutputType(OutputType type);
 
   // Item overrides.
-  virtual Target* AsTarget() OVERRIDE;
-  virtual const Target* AsTarget() const OVERRIDE;
-  virtual bool OnResolved(Err* err) OVERRIDE;
+  virtual Target* AsTarget() override;
+  virtual const Target* AsTarget() const override;
+  virtual bool OnResolved(Err* err) override;
 
   OutputType output_type() const { return output_type_; }
   void set_output_type(OutputType t) { output_type_ = t; }

tools/gn/toolchain.h

@@ -64,8 +64,8 @@ class Toolchain : public Item {
   virtual ~Toolchain();
 
   // Item overrides.
-  virtual Toolchain* AsToolchain() OVERRIDE;
-  virtual const Toolchain* AsToolchain() const OVERRIDE;
+  virtual Toolchain* AsToolchain() override;
+  virtual const Toolchain* AsToolchain() const override;
 
   // Returns TYPE_NONE on failure.
   static ToolType ToolNameToType(const base::StringPiece& str);

tools/ipc_fuzzer/mutate/generate.cc

@@ -104,65 +104,65 @@ class GeneratorImpl : public Generator {
   GeneratorImpl() {}
   virtual ~GeneratorImpl() {}
 
-  virtual void GenerateBool(bool* value) OVERRIDE {
+  virtual void GenerateBool(bool* value) override {
     *value = RandInRange(2);
   }
 
-  virtual void GenerateInt(int* value) OVERRIDE {
+  virtual void GenerateInt(int* value) override {
     GenerateIntegralType<int>(value);
   }
 
-  virtual void GenerateLong(long* value) OVERRIDE {
+  virtual void GenerateLong(long* value) override {
     GenerateIntegralType<long>(value);
   }
 
-  virtual void GenerateSize(size_t* value) OVERRIDE {
+  virtual void GenerateSize(size_t* value) override {
     GenerateIntegralType<size_t>(value);
   }
 
-  virtual void GenerateUChar(unsigned char* value) OVERRIDE {
+  virtual void GenerateUChar(unsigned char* value) override {
     GenerateIntegralType<unsigned char>(value);
   }
 
-  virtual void GenerateUInt16(uint16* value) OVERRIDE {
+  virtual void GenerateUInt16(uint16* value) override {
     GenerateIntegralType<uint16>(value);
   }
 
-  virtual void GenerateUInt32(uint32* value) OVERRIDE {
+  virtual void GenerateUInt32(uint32* value) override {
     GenerateIntegralType<uint32>(value);
   }
 
-  virtual void GenerateInt64(int64* value) OVERRIDE {
+  virtual void GenerateInt64(int64* value) override {
     GenerateIntegralType<int64>(value);
   }
 
-  virtual void GenerateUInt64(uint64* value) OVERRIDE {
+  virtual void GenerateUInt64(uint64* value) override {
     GenerateIntegralType<uint64>(value);
   }
 
-  virtual void GenerateFloat(float* value) OVERRIDE {
+  virtual void GenerateFloat(float* value) override {
     GenerateFloatingType<float>(value);
   }
 
-  virtual void GenerateDouble(double* value) OVERRIDE {
+  virtual void GenerateDouble(double* value) override {
     GenerateFloatingType<double>(value);
   }
 
-  virtual void GenerateString(std::string* value) OVERRIDE {
+  virtual void GenerateString(std::string* value) override {
     GenerateStringType<std::string>(value);
   }
 
-  virtual void GenerateString16(base::string16* value) OVERRIDE {
+  virtual void GenerateString16(base::string16* value) override {
     GenerateStringType<base::string16>(value);
   }
 
-  virtual void GenerateData(char* data, int length) OVERRIDE {
+  virtual void GenerateData(char* data, int length) override {
     for (int i = 0; i < length; ++i) {
       GenerateIntegralType<char>(&data[i]);
     }
   }
 
-  virtual void GenerateBytes(void* data, int data_len) OVERRIDE {
+  virtual void GenerateBytes(void* data, int data_len) override {
     GenerateData(static_cast<char*>(data), data_len);
   }
 };

tools/ipc_fuzzer/mutate/mutate.cc

@@ -94,64 +94,64 @@ class DefaultFuzzer : public Fuzzer {
 
   virtual ~DefaultFuzzer() {}
 
-  virtual void FuzzBool(bool* value) OVERRIDE {
+  virtual void FuzzBool(bool* value) override {
     if (RandEvent(frequency_))
       (*value) = !(*value);
   }
 
-  virtual void FuzzInt(int* value) OVERRIDE {
+  virtual void FuzzInt(int* value) override {
     FuzzIntegralType<int>(value, frequency_);
   }
 
-  virtual void FuzzLong(long* value) OVERRIDE {
+  virtual void FuzzLong(long* value) override {
     FuzzIntegralType<long>(value, frequency_);
   }
 
-  virtual void FuzzSize(size_t* value) OVERRIDE {
+  virtual void FuzzSize(size_t* value) override {
     FuzzIntegralType<size_t>(value, frequency_);
   }
 
-  virtual void FuzzUChar(unsigned char* value) OVERRIDE {
+  virtual void FuzzUChar(unsigned char* value) override {
     FuzzIntegralType<unsigned char>(value, frequency_);
   }
 
-  virtual void FuzzUInt16(uint16* value) OVERRIDE {
+  virtual void FuzzUInt16(uint16* value) override {
     FuzzIntegralType<uint16>(value, frequency_);
   }
 
-  virtual void FuzzUInt32(uint32* value) OVERRIDE {
+  virtual void FuzzUInt32(uint32* value) override {
     FuzzIntegralType<uint32>(value, frequency_);
   }
 
-  virtual void FuzzInt64(int64* value) OVERRIDE {
+  virtual void FuzzInt64(int64* value) override {
     FuzzIntegralType<int64>(value, frequency_);
   }
 
-  virtual void FuzzUInt64(uint64* value) OVERRIDE {
+  virtual void FuzzUInt64(uint64* value) override {
     FuzzIntegralType<uint64>(value, frequency_);
   }
 
-  virtual void FuzzFloat(float* value) OVERRIDE {
+  virtual void FuzzFloat(float* value) override {
     if (RandEvent(frequency_))
       *value = RandDouble();
   }
 
-  virtual void FuzzDouble(double* value) OVERRIDE {
+  virtual void FuzzDouble(double* value) override {
     if (RandEvent(frequency_))
       *value = RandDouble();
   }
 
-  virtual void FuzzString(std::string* value) OVERRIDE {
+  virtual void FuzzString(std::string* value) override {
     FuzzStringType<std::string>(value, frequency_, "BORKED", std::string());
   }
 
-  virtual void FuzzString16(base::string16* value) OVERRIDE {
+  virtual void FuzzString16(base::string16* value) override {
     FuzzStringType<base::string16>(value, frequency_,
                                    base::WideToUTF16(L"BORKED"),
                                    base::WideToUTF16(L""));
   }
 
-  virtual void FuzzData(char* data, int length) OVERRIDE {
+  virtual void FuzzData(char* data, int length) override {
     if (RandEvent(frequency_)) {
       for (int i = 0; i < length; ++i) {
         FuzzIntegralType<char>(&data[i], frequency_);
@@ -159,7 +159,7 @@ class DefaultFuzzer : public Fuzzer {
     }
   }
 
-  virtual void FuzzBytes(void* data, int data_len) OVERRIDE {
+  virtual void FuzzBytes(void* data, int data_len) override {
     FuzzData(static_cast<char*>(data), data_len);
   }
 
@@ -175,21 +175,21 @@ class NoOpFuzzer : public Fuzzer {
   NoOpFuzzer() {}
   virtual ~NoOpFuzzer() {}
 
-  virtual void FuzzBool(bool* value) OVERRIDE {}
-  virtual void FuzzInt(int* value) OVERRIDE {}
-  virtual void FuzzLong(long* value) OVERRIDE {}
-  virtual void FuzzSize(size_t* value) OVERRIDE {}
-  virtual void FuzzUChar(unsigned char* value) OVERRIDE {}
-  virtual void FuzzUInt16(uint16* value) OVERRIDE {}
-  virtual void FuzzUInt32(uint32* value) OVERRIDE {}
-  virtual void FuzzInt64(int64* value) OVERRIDE {}
-  virtual void FuzzUInt64(uint64* value) OVERRIDE {}
-  virtual void FuzzFloat(float* value) OVERRIDE {}
-  virtual void FuzzDouble(double* value) OVERRIDE {}
-  virtual void FuzzString(std::string* value) OVERRIDE {}
-  virtual void FuzzString16(base::string16* value) OVERRIDE {}
-  virtual void FuzzData(char* data, int length) OVERRIDE {}
-  virtual void FuzzBytes(void* data, int data_len) OVERRIDE {}
+  virtual void FuzzBool(bool* value) override {}
+  virtual void FuzzInt(int* value) override {}
+  virtual void FuzzLong(long* value) override {}
+  virtual void FuzzSize(size_t* value) override {}
+  virtual void FuzzUChar(unsigned char* value) override {}
+  virtual void FuzzUInt16(uint16* value) override {}
+  virtual void FuzzUInt32(uint32* value) override {}
+  virtual void FuzzInt64(int64* value) override {}
+  virtual void FuzzUInt64(uint64* value) override {}
+  virtual void FuzzFloat(float* value) override {}
+  virtual void FuzzDouble(double* value) override {}
+  virtual void FuzzString(std::string* value) override {}
+  virtual void FuzzString16(base::string16* value) override {}
+  virtual void FuzzData(char* data, int length) override {}
+  virtual void FuzzBytes(void* data, int data_len) override {}
 };
 
 class FuzzerFactory {

tools/ipc_fuzzer/replay/replay_process.h

@@ -37,8 +37,8 @@ class ReplayProcess : public IPC::Listener {
   void Run();
 
   // IPC::Listener implementation.
-  virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
-  virtual void OnChannelError() OVERRIDE;
+  virtual bool OnMessageReceived(const IPC::Message& message) override;
+  virtual void OnChannelError() override;
 
  private:
   void SendNextMessage();