Standardize usage of virtual/override/final in components/

components/autofill/core/browser/autofill_metrics_unittest.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 "components/autofill/core/browser/autofill_metrics.h"
 
 #include <vector>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 123 matching lines @@
   }
 
   bool autofill_enabled_;
 
   DISALLOW_COPY_AND_ASSIGN(TestPersonalDataManager);
 };
 
 class TestFormStructure : public FormStructure {
  public:
   explicit TestFormStructure(const FormData& form) : FormStructure(form) {}
-  virtual ~TestFormStructure() {}
+  ~TestFormStructure() override {}
 
   void SetFieldTypes(const std::vector<ServerFieldType>& heuristic_types,
                      const std::vector<ServerFieldType>& server_types) {
     ASSERT_EQ(field_count(), heuristic_types.size());
     ASSERT_EQ(field_count(), server_types.size());
 
     for (size_t i = 0; i < field_count(); ++i) {
       AutofillField* form_field = field(i);
       ASSERT_TRUE(form_field);
       form_field->set_heuristic_type(heuristic_types[i]);
       form_field->set_server_type(server_types[i]);
     }
 
     UpdateAutofillCount();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestFormStructure);
 };
 
 class TestAutofillManager : public AutofillManager {
  public:
   TestAutofillManager(AutofillDriver* driver,
                       AutofillClient* autofill_client,
                       TestPersonalDataManager* personal_manager)
       : AutofillManager(driver, autofill_client, personal_manager),
         autofill_enabled_(true) {
     set_metric_logger(new testing::NiceMock<MockAutofillMetrics>);
   }
-  virtual ~TestAutofillManager() {}
+  ~TestAutofillManager() override {}
 
-  virtual bool IsAutofillEnabled() const override { return autofill_enabled_; }
+  bool IsAutofillEnabled() const override { return autofill_enabled_; }
 
   void set_autofill_enabled(bool autofill_enabled) {
     autofill_enabled_ = autofill_enabled;
   }
 
   MockAutofillMetrics* metric_logger() {
     return static_cast<MockAutofillMetrics*>(const_cast<AutofillMetrics*>(
         AutofillManager::metric_logger()));
   }
 
@@ skipping 13 matching lines @@
 
   void FormSubmitted(const FormData& form, const TimeTicks& timestamp) {
     run_loop_.reset(new base::RunLoop());
     if (!OnFormSubmitted(form, timestamp))
       return;
 
     // Wait for the asynchronous FormSubmitted() call to complete.
     run_loop_->Run();
   }
 
-  virtual void UploadFormDataAsyncCallback(
+  void UploadFormDataAsyncCallback(
       const FormStructure* submitted_form,
       const base::TimeTicks& load_time,
       const base::TimeTicks& interaction_time,
       const base::TimeTicks& submission_time) override {
     run_loop_->Quit();
 
     AutofillManager::UploadFormDataAsyncCallback(submitted_form,
                                                  load_time,
                                                  interaction_time,
                                                  submission_time);
@@ skipping 861 matching lines @@
     autofill_manager_->OnFormsSeen(second_forms,
                                    TimeTicks::FromInternalValue(5));
     autofill_manager_->FormSubmitted(second_form,
                                      TimeTicks::FromInternalValue(17));
     autofill_manager_->Reset();
     Mock::VerifyAndClearExpectations(autofill_manager_->metric_logger());
   }
 }
 
 }  // namespace autofill