replace OVERRIDE and FINAL with override and final in chrome/browser/ui/[a-s]*

chrome/browser/ui/autofill/autofill_dialog_controller_browsertest.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 "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 77 matching lines @@
 }
 
 class MockAutofillMetrics : public AutofillMetrics {
  public:
   MockAutofillMetrics()
       : dialog_dismissal_action_(static_cast<DialogDismissalAction>(-1)) {}
   virtual ~MockAutofillMetrics() {}
 
   virtual void LogDialogUiDuration(
       const base::TimeDelta& duration,
-      DialogDismissalAction dismissal_action) const OVERRIDE {
+      DialogDismissalAction dismissal_action) const override {
     // Ignore constness for testing.
     MockAutofillMetrics* mutable_this = const_cast<MockAutofillMetrics*>(this);
     mutable_this->dialog_dismissal_action_ = dismissal_action;
   }
 
   AutofillMetrics::DialogDismissalAction dialog_dismissal_action() const {
     return dialog_dismissal_action_;
   }
 
   MOCK_CONST_METHOD1(LogDialogDismissalState,
@@ skipping 25 matching lines @@
         sign_in_user_index_(0U),
         weak_ptr_factory_(this) {
     test_manager_.Init(
         NULL,
         Profile::FromBrowserContext(contents->GetBrowserContext())->GetPrefs(),
         false);
   }
 
   virtual ~TestAutofillDialogController() {}
 
-  virtual GURL SignInUrl() const OVERRIDE {
+  virtual GURL SignInUrl() const override {
     return GURL(chrome::kChromeUIVersionURL);
   }
 
-  virtual void ViewClosed() OVERRIDE {
+  virtual void ViewClosed() override {
     message_loop_runner_->Quit();
     AutofillDialogControllerImpl::ViewClosed();
   }
 
   virtual base::string16 InputValidityMessage(
       DialogSection section,
       ServerFieldType type,
-      const base::string16& value) OVERRIDE {
+      const base::string16& value) override {
     if (!use_validation_)
       return base::string16();
     return AutofillDialogControllerImpl::InputValidityMessage(
         section, type, value);
   }
 
   virtual ValidityMessages InputsAreValid(
       DialogSection section,
-      const FieldValueMap& inputs) OVERRIDE {
+      const FieldValueMap& inputs) override {
     if (!use_validation_)
       return ValidityMessages();
     return AutofillDialogControllerImpl::InputsAreValid(section, inputs);
   }
 
   // Saving to Chrome is tested in AutofillDialogControllerImpl unit tests.
   // TODO(estade): test that the view defaults to saving to Chrome.
-  virtual bool ShouldOfferToSaveInChrome() const OVERRIDE {
+  virtual bool ShouldOfferToSaveInChrome() const override {
     return true;
   }
 
   void ForceFinishSubmit() {
     DoFinishSubmit();
   }
 
   // Increase visibility for testing.
   using AutofillDialogControllerImpl::view;
   using AutofillDialogControllerImpl::popup_input_type;
 
   MOCK_METHOD0(LoadRiskFingerprintData, void());
 
-  virtual std::vector<DialogNotification> CurrentNotifications() OVERRIDE {
+  virtual std::vector<DialogNotification> CurrentNotifications() override {
     return notifications_;
   }
 
   void set_notifications(const std::vector<DialogNotification>& notifications) {
     notifications_ = notifications;
   }
 
   TestPersonalDataManager* GetTestingManager() {
     return &test_manager_;
   }
@@ skipping 21 matching lines @@
 
   wallet::MockWalletClient* GetTestingWalletClient() {
     return &mock_wallet_client_;
   }
 
   void set_sign_in_user_index(size_t sign_in_user_index) {
     sign_in_user_index_ = sign_in_user_index;
   }
 
  protected:
-  virtual PersonalDataManager* GetManager() const OVERRIDE {
+  virtual PersonalDataManager* GetManager() const override {
     return &const_cast<TestAutofillDialogController*>(this)->test_manager_;
   }
 
-  virtual AddressValidator* GetValidator() OVERRIDE {
+  virtual AddressValidator* GetValidator() override {
     return &mock_validator_;
   }
 
-  virtual wallet::WalletClient* GetWalletClient() OVERRIDE {
+  virtual wallet::WalletClient* GetWalletClient() override {
     return &mock_wallet_client_;
   }
 
   virtual bool IsSignInContinueUrl(const GURL& url, size_t* user_index) const
-      OVERRIDE {
+      override {
     *user_index = sign_in_user_index_;
     return url == wallet::GetSignInContinueUrl();
   }
 
  private:
   // To specify our own metric logger.
-  virtual const AutofillMetrics& GetMetricLogger() const OVERRIDE {
+  virtual const AutofillMetrics& GetMetricLogger() const override {
     return metric_logger_;
   }
 
   const AutofillMetrics& metric_logger_;
   TestPersonalDataManager test_manager_;
   testing::NiceMock<MockAddressValidator> mock_validator_;
   testing::NiceMock<wallet::MockWalletClient> mock_wallet_client_;
   scoped_refptr<content::MessageLoopRunner> message_loop_runner_;
   bool use_validation_;
 
@@ skipping 22 matching lines @@
                             const content::NotificationSource& source)
     : WindowedNotificationObserver(content::NOTIFICATION_NAV_ENTRY_COMMITTED,
                                    source),
       url_(url) {}
 
   virtual ~NavEntryCommittedObserver() {}
 
   // content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details) OVERRIDE {
+                       const content::NotificationDetails& details) override {
     content::LoadCommittedDetails* load_details =
         content::Details<content::LoadCommittedDetails>(details).ptr();
     if (load_details->entry->GetVirtualURL() != url_)
       return;
 
     WindowedNotificationObserver::Observe(type, source, details);
   }
 
  private:
   GURL url_;
 
   DISALLOW_COPY_AND_ASSIGN(NavEntryCommittedObserver);
 };
 
 }  // namespace
 
 class AutofillDialogControllerTest : public InProcessBrowserTest {
  public:
   AutofillDialogControllerTest() : controller_(NULL) {}
   virtual ~AutofillDialogControllerTest() {}
 
-  virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
+  virtual void SetUpCommandLine(CommandLine* command_line) override {
     command_line->AppendSwitch(::switches::kReduceSecurityForTesting);
   }
 
-  virtual void SetUpOnMainThread() OVERRIDE {
+  virtual void SetUpOnMainThread() override {
     autofill::test::DisableSystemServices(browser()->profile()->GetPrefs());
     InitializeController();
   }
 
  protected:
   bool SectionHasField(DialogSection section, ServerFieldType type) {
     const DetailInputs& fields =
         controller()->RequestedFieldsForSection(section);
     for (size_t i = 0; i < fields.size(); ++i) {
       if (type == fields[i].type)
@@ skipping 1165 matching lines @@
   EXPECT_TRUE(RunTestPage(http_server));
 }
 
 // Like the parent test, but doesn't add the --reduce-security-for-testing flag.
 class AutofillDialogControllerSecurityTest :
     public AutofillDialogControllerTest {
  public:
   AutofillDialogControllerSecurityTest() {}
   virtual ~AutofillDialogControllerSecurityTest() {}
 
-  virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
+  virtual void SetUpCommandLine(CommandLine* command_line) override {
     CHECK(!command_line->HasSwitch(::switches::kReduceSecurityForTesting));
   }
 
   typedef net::BaseTestServer::SSLOptions SSLOptions;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AutofillDialogControllerSecurityTest);
 };
 
 IN_PROC_BROWSER_TEST_F(AutofillDialogControllerSecurityTest,
@@ skipping 251 matching lines @@
       "<input autocomplete='transaction-currency' value='USD'>"
       "<input autocomplete='cc-csc'>");
   AutofillDialogControllerImpl* controller = SetUpHtmlAndInvoke(html);
   ASSERT_TRUE(controller);
 
   EXPECT_EQ(ASCIIToUTF16("24"), controller->transaction_amount_);
   EXPECT_EQ(ASCIIToUTF16("USD"), controller->transaction_currency_);
 }
 
 }  // namespace autofill