Replace OVERRIDE with its C++11 counterpart in components/password_manager/

components/password_manager/core/browser/password_generation_manager_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 <vector>
 
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/testing_pref_service.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 20 matching lines @@
 class TestPasswordManagerDriver : public StubPasswordManagerDriver {
  public:
   TestPasswordManagerDriver(PasswordManagerClient* client)
       : password_manager_(client),
         password_generation_manager_(client),
         password_autofill_manager_(client, NULL),
         is_off_the_record_(false) {}
   virtual ~TestPasswordManagerDriver() {}
 
   // PasswordManagerDriver implementation.
-  virtual bool IsOffTheRecord() OVERRIDE { return is_off_the_record_; }
-  virtual PasswordGenerationManager* GetPasswordGenerationManager() OVERRIDE {
+  virtual bool IsOffTheRecord() override { return is_off_the_record_; }
+  virtual PasswordGenerationManager* GetPasswordGenerationManager() override {
     return &password_generation_manager_;
   }
-  virtual PasswordManager* GetPasswordManager() OVERRIDE {
+  virtual PasswordManager* GetPasswordManager() override {
     return &password_manager_;
   }
-  virtual PasswordAutofillManager* GetPasswordAutofillManager() OVERRIDE {
+  virtual PasswordAutofillManager* GetPasswordAutofillManager() override {
     return &password_autofill_manager_;
   }
   virtual void AccountCreationFormsFound(
-      const std::vector<autofill::FormData>& forms) OVERRIDE {
+      const std::vector<autofill::FormData>& forms) override {
     found_account_creation_forms_.insert(
         found_account_creation_forms_.begin(), forms.begin(), forms.end());
   }
 
   const std::vector<autofill::FormData>& GetFoundAccountCreationForms() {
     return found_account_creation_forms_;
   }
   void set_is_off_the_record(bool is_off_the_record) {
     is_off_the_record_ = is_off_the_record;
   }
 
  private:
   PasswordManager password_manager_;
   PasswordGenerationManager password_generation_manager_;
   PasswordAutofillManager password_autofill_manager_;
   std::vector<autofill::FormData> found_account_creation_forms_;
   bool is_off_the_record_;
 };
 
 class TestPasswordManagerClient : public StubPasswordManagerClient {
  public:
   TestPasswordManagerClient(scoped_ptr<PrefService> prefs)
       : prefs_(prefs.Pass()), driver_(this), is_sync_enabled_(false) {}
 
-  virtual PasswordStore* GetPasswordStore() OVERRIDE { return NULL; }
-  virtual PrefService* GetPrefs() OVERRIDE { return prefs_.get(); }
-  virtual PasswordManagerDriver* GetDriver() OVERRIDE { return &driver_; }
+  virtual PasswordStore* GetPasswordStore() override { return NULL; }
+  virtual PrefService* GetPrefs() override { return prefs_.get(); }
+  virtual PasswordManagerDriver* GetDriver() override { return &driver_; }
   virtual void AuthenticateAutofillAndFillForm(
-      scoped_ptr<autofill::PasswordFormFillData> fill_data) OVERRIDE {}
-  virtual bool IsPasswordSyncEnabled() OVERRIDE { return is_sync_enabled_; }
+      scoped_ptr<autofill::PasswordFormFillData> fill_data) override {}
+  virtual bool IsPasswordSyncEnabled() override { return is_sync_enabled_; }
 
   void set_is_password_sync_enabled(bool enabled) {
     is_sync_enabled_ = enabled;
   }
 
  private:
   scoped_ptr<PrefService> prefs_;
   TestPasswordManagerDriver driver_;
   bool is_sync_enabled_;
 };
 
 // Unlike the base AutofillMetrics, exposes copy and assignment constructors,
 // which are handy for briefer test code.  The AutofillMetrics class is
 // stateless, so this is safe.
 class TestAutofillMetrics : public autofill::AutofillMetrics {
  public:
   TestAutofillMetrics() {}
   virtual ~TestAutofillMetrics() {}
 };
 
 }  // anonymous namespace
 
 class PasswordGenerationManagerTest : public testing::Test {
  protected:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     // Construct a PrefService and register all necessary prefs before handing
     // it off to |client_|, as the initialization flow of |client_| will
     // indirectly cause those prefs to be immediately accessed.
     scoped_ptr<TestingPrefServiceSimple> prefs(new TestingPrefServiceSimple());
     prefs->registry()->RegisterBooleanPref(prefs::kPasswordManagerSavingEnabled,
                                            true);
     client_.reset(new TestPasswordManagerClient(prefs.PassAs<PrefService>()));
   }
 
-  virtual void TearDown() OVERRIDE { client_.reset(); }
+  virtual void TearDown() override { client_.reset(); }
 
   PasswordGenerationManager* GetGenerationManager() {
     return client_->GetDriver()->GetPasswordGenerationManager();
   }
 
   TestPasswordManagerDriver* GetTestDriver() {
     return static_cast<TestPasswordManagerDriver*>(client_->GetDriver());
   }
 
   bool IsGenerationEnabled() {
@@ skipping 84 matching lines @@
   // be disabled.
   GetTestDriver()->set_is_off_the_record(true);
   PrefService* prefs = client_->GetPrefs();
   prefs->SetBoolean(prefs::kPasswordManagerSavingEnabled, true);
   client_->set_is_password_sync_enabled(true);
 
   EXPECT_FALSE(IsGenerationEnabled());
 }
 
 }  // namespace password_manager