Replacing the OVERRIDE with override in tools folder

tools/ipc_fuzzer/mutate/generate.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 <stdlib.h>
 
 #include <algorithm>
 #include <iostream>
 #include <ostream>
 #include <set>
@@ skipping 86 matching lines @@
   for (size_t i = 0; i < length; ++i)
     temp_string += RandInRange(256);
   *value = temp_string;
 }
 
 class GeneratorImpl : public Generator {
  public:
   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);
   }
 };
 
 // Partially-specialized class that knows how to generate a given type.
 template <class P>
 struct GenerateTraits {
   static bool Generate(P* p, Generator *generator) {
     // This is the catch-all for types we don't have enough information
     // to generate.
@@ skipping 1159 matching lines @@
     return EXIT_FAILURE;
 
   return EXIT_SUCCESS;
 }
 
 }  // namespace ipc_fuzzer
 
 int main(int argc, char** argv) {
   return ipc_fuzzer::GenerateMain(argc, argv);
 }