replace 'virtual ... OVERRIDE' with '... override'

base/json/json_value_converter.h

 // Copyright (c) 2012 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.
 
 #ifndef BASE_JSON_JSON_VALUE_CONVERTER_H_
 #define BASE_JSON_JSON_VALUE_CONVERTER_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 104 matching lines @@
 class FieldConverter : public FieldConverterBase<StructType> {
  public:
   explicit FieldConverter(const std::string& path,
                           FieldType StructType::* field,
                           ValueConverter<FieldType>* converter)
       : FieldConverterBase<StructType>(path),
         field_pointer_(field),
         value_converter_(converter) {
   }
 
-  virtual bool ConvertField(
-      const base::Value& value, StructType* dst) const OVERRIDE {
+  bool ConvertField(const base::Value& value, StructType* dst) const override {
     return value_converter_->Convert(value, &(dst->*field_pointer_));
   }
 
  private:
   FieldType StructType::* field_pointer_;
   scoped_ptr<ValueConverter<FieldType> > value_converter_;
   DISALLOW_COPY_AND_ASSIGN(FieldConverter);
 };
 
 template <typename FieldType>
 class BasicValueConverter;
 
 template <>
 class BasicValueConverter<int> : public ValueConverter<int> {
  public:
   BasicValueConverter() {}
 
-  virtual bool Convert(const base::Value& value, int* field) const OVERRIDE {
+  bool Convert(const base::Value& value, int* field) const override {
     return value.GetAsInteger(field);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BasicValueConverter);
 };
 
 template <>
 class BasicValueConverter<std::string> : public ValueConverter<std::string> {
  public:
   BasicValueConverter() {}
 
-  virtual bool Convert(
-      const base::Value& value, std::string* field) const OVERRIDE {
+  bool Convert(const base::Value& value, std::string* field) const override {
     return value.GetAsString(field);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BasicValueConverter);
 };
 
 template <>
 class BasicValueConverter<string16> : public ValueConverter<string16> {
  public:
   BasicValueConverter() {}
 
-  virtual bool Convert(
-      const base::Value& value, string16* field) const OVERRIDE {
+  bool Convert(const base::Value& value, string16* field) const override {
     return value.GetAsString(field);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BasicValueConverter);
 };
 
 template <>
 class BasicValueConverter<double> : public ValueConverter<double> {
  public:
   BasicValueConverter() {}
 
-  virtual bool Convert(const base::Value& value, double* field) const OVERRIDE {
+  bool Convert(const base::Value& value, double* field) const override {
     return value.GetAsDouble(field);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BasicValueConverter);
 };
 
 template <>
 class BasicValueConverter<bool> : public ValueConverter<bool> {
  public:
   BasicValueConverter() {}
 
-  virtual bool Convert(const base::Value& value, bool* field) const OVERRIDE {
+  bool Convert(const base::Value& value, bool* field) const override {
     return value.GetAsBoolean(field);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BasicValueConverter);
 };
 
 template <typename FieldType>
 class ValueFieldConverter : public ValueConverter<FieldType> {
  public:
   typedef bool(*ConvertFunc)(const base::Value* value, FieldType* field);
 
   ValueFieldConverter(ConvertFunc convert_func)
       : convert_func_(convert_func) {}
 
-  virtual bool Convert(const base::Value& value,
-                       FieldType* field) const OVERRIDE {
+  bool Convert(const base::Value& value, FieldType* field) const override {
     return convert_func_(&value, field);
   }
 
  private:
   ConvertFunc convert_func_;
 
   DISALLOW_COPY_AND_ASSIGN(ValueFieldConverter);
 };
 
 template <typename FieldType>
 class CustomFieldConverter : public ValueConverter<FieldType> {
  public:
   typedef bool(*ConvertFunc)(const StringPiece& value, FieldType* field);
 
   CustomFieldConverter(ConvertFunc convert_func)
       : convert_func_(convert_func) {}
 
-  virtual bool Convert(const base::Value& value,
-                       FieldType* field) const OVERRIDE {
+  bool Convert(const base::Value& value, FieldType* field) const override {
     std::string string_value;
     return value.GetAsString(&string_value) &&
         convert_func_(string_value, field);
   }
 
  private:
   ConvertFunc convert_func_;
 
   DISALLOW_COPY_AND_ASSIGN(CustomFieldConverter);
 };
 
 template <typename NestedType>
 class NestedValueConverter : public ValueConverter<NestedType> {
  public:
   NestedValueConverter() {}
 
-  virtual bool Convert(
-      const base::Value& value, NestedType* field) const OVERRIDE {
+  bool Convert(const base::Value& value, NestedType* field) const override {
     return converter_.Convert(value, field);
   }
 
  private:
   JSONValueConverter<NestedType> converter_;
   DISALLOW_COPY_AND_ASSIGN(NestedValueConverter);
 };
 
 template <typename Element>
 class RepeatedValueConverter : public ValueConverter<ScopedVector<Element> > {
  public:
   RepeatedValueConverter() {}
 
-  virtual bool Convert(
-      const base::Value& value, ScopedVector<Element>* field) const OVERRIDE {
+  bool Convert(const base::Value& value,
+               ScopedVector<Element>* field) const override {
     const base::ListValue* list = NULL;
     if (!value.GetAsList(&list)) {
       // The field is not a list.
       return false;
     }
 
     field->reserve(list->GetSize());
     for (size_t i = 0; i < list->GetSize(); ++i) {
       const base::Value* element = NULL;
       if (!list->Get(i, &element))
@@ skipping 14 matching lines @@
   BasicValueConverter<Element> basic_converter_;
   DISALLOW_COPY_AND_ASSIGN(RepeatedValueConverter);
 };
 
 template <typename NestedType>
 class RepeatedMessageConverter
     : public ValueConverter<ScopedVector<NestedType> > {
  public:
   RepeatedMessageConverter() {}
 
-  virtual bool Convert(const base::Value& value,
-                       ScopedVector<NestedType>* field) const OVERRIDE {
+  bool Convert(const base::Value& value,
+               ScopedVector<NestedType>* field) const override {
     const base::ListValue* list = NULL;
     if (!value.GetAsList(&list))
       return false;
 
     field->reserve(list->GetSize());
     for (size_t i = 0; i < list->GetSize(); ++i) {
       const base::Value* element = NULL;
       if (!list->Get(i, &element))
         continue;
 
@@ skipping 15 matching lines @@
 
 template <typename NestedType>
 class RepeatedCustomValueConverter
     : public ValueConverter<ScopedVector<NestedType> > {
  public:
   typedef bool(*ConvertFunc)(const base::Value* value, NestedType* field);
 
   RepeatedCustomValueConverter(ConvertFunc convert_func)
       : convert_func_(convert_func) {}
 
-  virtual bool Convert(const base::Value& value,
-                       ScopedVector<NestedType>* field) const OVERRIDE {
+  bool Convert(const base::Value& value,
+               ScopedVector<NestedType>* field) const override {
     const base::ListValue* list = NULL;
     if (!value.GetAsList(&list))
       return false;
 
     field->reserve(list->GetSize());
     for (size_t i = 0; i < list->GetSize(); ++i) {
       const base::Value* element = NULL;
       if (!list->Get(i, &element))
         continue;
 
@@ skipping 167 matching lines @@
 
  private:
   ScopedVector<internal::FieldConverterBase<StructType> > fields_;
 
   DISALLOW_COPY_AND_ASSIGN(JSONValueConverter);
 };
 
 }  // namespace base
 
 #endif  // BASE_JSON_JSON_VALUE_CONVERTER_H_