Standardize usage of virtual/override/final in components/

components/autofill/core/browser/autofill_manager_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 <algorithm>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/format_macros.h"
 #include "base/memory/ref_counted.h"
@@ skipping 367 matching lines @@
 };
 
 class TestAutofillManager : public AutofillManager {
  public:
   TestAutofillManager(AutofillDriver* driver,
                       autofill::AutofillClient* client,
                       TestPersonalDataManager* personal_data)
       : AutofillManager(driver, client, personal_data),
         personal_data_(personal_data),
         autofill_enabled_(true) {}
-  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;
   }
 
   void set_expected_submitted_field_types(
       const std::vector<ServerFieldTypeSet>& expected_types) {
     expected_submitted_field_types_ = expected_types;
   }
 
-  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();
 
     // If we have expected field types set, make sure they match.
     if (!expected_submitted_field_types_.empty()) {
       ASSERT_EQ(expected_submitted_field_types_.size(),
                 submitted_form->field_count());
@@ skipping 21 matching lines @@
                                                  submission_time);
   }
 
   // Resets the run loop so that it can wait for an asynchronous form
   // submission to complete.
   void ResetRunLoop() { run_loop_.reset(new base::RunLoop()); }
 
   // Wait for the asynchronous OnFormSubmitted() call to complete.
   void WaitForAsyncFormSubmit() { run_loop_->Run(); }
 
-  virtual void UploadFormData(const FormStructure& submitted_form) override {
+  void UploadFormData(const FormStructure& submitted_form) override {
     submitted_form_signature_ = submitted_form.FormSignature();
   }
 
   const std::string GetSubmittedFormSignature() {
     return submitted_form_signature_;
   }
 
   AutofillProfile* GetProfileWithGUID(const char* guid) {
     return personal_data_->GetProfileWithGUID(guid);
   }
@@ skipping 39 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(TestAutofillManager);
 };
 
 class TestAutofillExternalDelegate : public AutofillExternalDelegate {
  public:
   explicit TestAutofillExternalDelegate(AutofillManager* autofill_manager,
                                         AutofillDriver* autofill_driver)
       : AutofillExternalDelegate(autofill_manager, autofill_driver),
         on_query_seen_(false),
         on_suggestions_returned_seen_(false) {}
-  virtual ~TestAutofillExternalDelegate() {}
+  ~TestAutofillExternalDelegate() override {}
 
-  virtual void OnQuery(int query_id,
-                       const FormData& form,
-                       const FormFieldData& field,
-                       const gfx::RectF& bounds,
-                       bool display_warning) override {
+  void OnQuery(int query_id,
+               const FormData& form,
+               const FormFieldData& field,
+               const gfx::RectF& bounds,
+               bool display_warning) override {
     on_query_seen_ = true;
     on_suggestions_returned_seen_ = false;
   }
 
-  virtual void OnSuggestionsReturned(
+  void OnSuggestionsReturned(
       int query_id,
       const std::vector<base::string16>& autofill_values,
       const std::vector<base::string16>& autofill_labels,
       const std::vector<base::string16>& autofill_icons,
       const std::vector<int>& autofill_unique_ids) override {
     on_suggestions_returned_seen_ = true;
 
     query_id_ = query_id;
     autofill_values_ = autofill_values;
     autofill_labels_ = autofill_labels;
@@ skipping 148 matching lines @@
   scoped_ptr<MockAutofillDriver> autofill_driver_;
   scoped_ptr<TestAutofillManager> autofill_manager_;
   scoped_ptr<TestAutofillExternalDelegate> external_delegate_;
   TestPersonalDataManager personal_data_;
 };
 
 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]);
@@ skipping 2182 matching lines @@
       autofill_manager_->ShouldShowAccessAddressBookSuggestion(form, field));
 }
 #endif  // defined(OS_MACOSX) && !defined(OS_IOS)
 
 namespace {
 
 class MockAutofillClient : public TestAutofillClient {
  public:
   MockAutofillClient() {}
 
-  virtual ~MockAutofillClient() {}
+  ~MockAutofillClient() override {}
 
-  virtual void ShowRequestAutocompleteDialog(
-      const FormData& form,
-      const GURL& source_url,
-      const ResultCallback& callback) override {
+  void ShowRequestAutocompleteDialog(const FormData& form,
+                                     const GURL& source_url,
+                                     const ResultCallback& callback) override {
     callback.Run(user_supplied_data_ ? AutocompleteResultSuccess :
                                        AutocompleteResultErrorDisabled,
                  base::string16(),
                  user_supplied_data_.get());
   }
 
   void SetUserSuppliedData(scoped_ptr<FormStructure> user_supplied_data) {
     user_supplied_data_.reset(user_supplied_data.release());
   }
 
@@ skipping 11 matching lines @@
   test::CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
   const FormFieldData& field = form.fields[0];
   GetAutofillSuggestions(form, field);  // should call the delegate's OnQuery()
 
   EXPECT_TRUE(external_delegate_->on_query_seen());
 }
 
 }  // namespace autofill