replace OVERRIDE and FINAL with override and final in chrome/browser/[j-q]*

chrome/browser/metrics/variations/variations_service_unittest.cc

 // 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.
 
 #include "chrome/browser/metrics/variations/variations_service.h"
 
 #include <vector>
 
 #include "base/base64.h"
 #include "base/prefs/testing_pref_service.h"
@@ skipping 40 matching lines @@
   }
 
   void set_intercepts_fetch(bool value) {
     intercepts_fetch_ = value;
   }
 
   bool fetch_attempted() const { return fetch_attempted_; }
 
   bool seed_stored() const { return seed_stored_; }
 
-  virtual void DoActualFetch() OVERRIDE {
+  virtual void DoActualFetch() override {
     if (intercepts_fetch_) {
       fetch_attempted_ = true;
       return;
     }
 
     VariationsService::DoActualFetch();
   }
 
  protected:
   virtual void StoreSeed(const std::string& seed_data,
                          const std::string& seed_signature,
-                         const base::Time& date_fetched) OVERRIDE {
+                         const base::Time& date_fetched) override {
     seed_stored_ = true;
   }
 
  private:
   bool intercepts_fetch_;
   bool fetch_attempted_;
   bool seed_stored_;
 
   DISALLOW_COPY_AND_ASSIGN(TestVariationsService);
 };
 
 class TestVariationsServiceObserver : public VariationsService::Observer {
  public:
   TestVariationsServiceObserver()
       : best_effort_changes_notified_(0),
         crticial_changes_notified_(0) {
   }
   virtual ~TestVariationsServiceObserver() {
   }
 
-  virtual void OnExperimentChangesDetected(Severity severity) OVERRIDE {
+  virtual void OnExperimentChangesDetected(Severity severity) override {
     switch (severity) {
       case BEST_EFFORT:
         ++best_effort_changes_notified_;
         break;
       case CRITICAL:
         ++crticial_changes_notified_;
         break;
     }
   }
 
@@ skipping 86 matching lines @@
   url = VariationsService::GetVariationsServerURL(&prefs);
   EXPECT_TRUE(StartsWithASCII(url.spec(), default_variations_url, true));
   EXPECT_TRUE(net::GetValueForKeyInQuery(url, "restrict", &value));
   EXPECT_EQ("restricted", value);
 }
 #else
 class VariationsServiceTestChromeOS : public VariationsServiceTest {
  protected:
   VariationsServiceTestChromeOS() {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     cros_settings_ = chromeos::CrosSettings::Get();
     DCHECK(cros_settings_ != NULL);
     // Remove the real DeviceSettingsProvider and replace it with a stub that
     // allows modifications in a test.
     device_settings_provider_ = cros_settings_->GetProvider(
         chromeos::kReportDeviceVersionInfo);
     EXPECT_TRUE(device_settings_provider_ != NULL);
     EXPECT_TRUE(cros_settings_->RemoveSettingsProvider(
         device_settings_provider_));
     cros_settings_->AddSettingsProvider(&stub_settings_provider_);
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     // Restore the real DeviceSettingsProvider.
     EXPECT_TRUE(
         cros_settings_->RemoveSettingsProvider(&stub_settings_provider_));
     cros_settings_->AddSettingsProvider(device_settings_provider_);
   }
 
   void SetVariationsRestrictParameterPolicyValue(std::string value) {
     cros_settings_->SetString(chromeos::kVariationsRestrictParameter, value);
   }
 
@@ skipping 181 matching lines @@
     EXPECT_EQ(cases[i].expected_best_effort_notifications,
               observer.best_effort_changes_notified()) << i;
     EXPECT_EQ(cases[i].expected_crtical_notifications,
               observer.crticial_changes_notified()) << i;
 
     service.RemoveObserver(&observer);
   }
 }
 
 }  // namespace chrome_variations