replace OVERRIDE and FINAL with override and final in chrome/browser/[r-z]*

chrome/browser/safe_browsing/incident_reporting/preference_validation_delegate_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 "chrome/browser/safe_browsing/incident_reporting/preference_validation_delegate.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_vector.h"
 #include "base/values.h"
 #include "chrome/common/safe_browsing/csd.pb.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 // A basic test harness that creates a delegate instance for which it stores all
 // incidents. Tests can push data to the delegate and verify that the test
 // instance was provided with the expected data.
 class PreferenceValidationDelegateTest : public testing::Test {
  protected:
   typedef ScopedVector<safe_browsing::ClientIncidentReport_IncidentData>
       IncidentVector;
 
   PreferenceValidationDelegateTest()
       : kPrefPath_("atomic.pref"),
         null_value_(base::Value::CreateNullValue()) {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     testing::Test::SetUp();
     invalid_keys_.push_back(std::string("one"));
     invalid_keys_.push_back(std::string("two"));
     instance_.reset(new safe_browsing::PreferenceValidationDelegate(
         base::Bind(&PreferenceValidationDelegateTest::AddIncident,
                    base::Unretained(this))));
   }
 
   void AddIncident(
       scoped_ptr<safe_browsing::ClientIncidentReport_IncidentData> data) {
@@ skipping 56 matching lines @@
 }
 
 // Tests that all supported value types can be stringified into an incident. The
 // parameters for the test are the type of value to test and the expected value
 // string.
 class PreferenceValidationDelegateValues
     : public PreferenceValidationDelegateTest,
       public testing::WithParamInterface<
           std::tr1::tuple<base::Value::Type, const char*> > {
  protected:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     PreferenceValidationDelegateTest::SetUp();
     value_type_ = std::tr1::get<0>(GetParam());
     expected_value_ = std::tr1::get<1>(GetParam());
   }
 
   static scoped_ptr<base::Value> MakeValue(base::Value::Type value_type) {
     using base::Value;
     switch (value_type) {
       case Value::TYPE_NULL:
         return make_scoped_ptr(Value::CreateNullValue());
@@ skipping 59 matching lines @@
         std::tr1::make_tuple(base::Value::TYPE_DICTIONARY,
             const_cast<char*>("{\"forty-seven\":47,\"twenty-two\":22}")),
         std::tr1::make_tuple(base::Value::TYPE_LIST,
                              const_cast<char*>("[22,47]"))));
 
 // Tests that no incidents are reported for relevant combinations of ValueState.
 class PreferenceValidationDelegateNoIncident
     : public PreferenceValidationDelegateTest,
       public testing::WithParamInterface<PrefHashStoreTransaction::ValueState> {
  protected:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     PreferenceValidationDelegateTest::SetUp();
     value_state_ = GetParam();
   }
 
   PrefHashStoreTransaction::ValueState value_state_;
 };
 
 TEST_P(PreferenceValidationDelegateNoIncident, Atomic) {
   instance_->OnAtomicPreferenceValidation(kPrefPath_,
                                           null_value_.get(),
@@ skipping 19 matching lines @@
                     PrefHashStoreTransaction::TRUSTED_UNKNOWN_VALUE));
 
 // Tests that incidents are reported for relevant combinations of ValueState and
 // ResetAction.
 class PreferenceValidationDelegateWithIncident
     : public PreferenceValidationDelegateTest,
       public testing::WithParamInterface<
           std::tr1::tuple<PrefHashStoreTransaction::ValueState,
                           TrackedPreferenceHelper::ResetAction> > {
  protected:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     PreferenceValidationDelegateTest::SetUp();
     value_state_ = std::tr1::get<0>(GetParam());
     reset_action_ = std::tr1::get<1>(GetParam());
   }
 
   PrefHashStoreTransaction::ValueState value_state_;
   TrackedPreferenceHelper::ResetAction reset_action_;
 };
 
 TEST_P(PreferenceValidationDelegateWithIncident, Atomic) {
@@ skipping 33 matching lines @@
 
 INSTANTIATE_TEST_CASE_P(
     WithIncident,
     PreferenceValidationDelegateWithIncident,
     testing::Combine(
         testing::Values(PrefHashStoreTransaction::CLEARED,
                         PrefHashStoreTransaction::CHANGED,
                         PrefHashStoreTransaction::UNTRUSTED_UNKNOWN_VALUE),
         testing::Values(TrackedPreferenceHelper::WANTED_RESET,
                         TrackedPreferenceHelper::DO_RESET)));