replace OVERRIDE and FINAL with override and final in chrome/browser/extensions/

chrome/browser/extensions/chrome_app_sorting_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 "chrome/browser/extensions/chrome_app_sorting.h"
 
 #include <map>
 
 #include "chrome/browser/extensions/./extension_prefs_unittest.h"
 #include "components/crx_file/id_util.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/manifest_constants.h"
 #include "sync/api/string_ordinal.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace extensions {
 
 namespace keys = manifest_keys;
 
 class ChromeAppSortingTest : public ExtensionPrefsTest {
  protected:
   ChromeAppSorting* app_sorting() {
     return static_cast<ChromeAppSorting*>(prefs()->app_sorting());
   }
 };
 
 class ChromeAppSortingAppLocation : public ChromeAppSortingTest {
  public:
-  virtual void Initialize() OVERRIDE {
+  virtual void Initialize() override {
     extension_ = prefs_.AddExtension("not_an_app");
     // Non-apps should not have any app launch ordinal or page ordinal.
     prefs()->OnExtensionInstalled(extension_.get(),
                                   Extension::ENABLED,
                                   syncer::StringOrdinal(),
                                   std::string());
   }
 
-  virtual void Verify() OVERRIDE {
+  virtual void Verify() override {
     EXPECT_FALSE(
         app_sorting()->GetAppLaunchOrdinal(extension_->id()).IsValid());
     EXPECT_FALSE(
         app_sorting()->GetPageOrdinal(extension_->id()).IsValid());
   }
 
  private:
   scoped_refptr<Extension> extension_;
 };
 TEST_F(ChromeAppSortingAppLocation, ChromeAppSortingAppLocation) {}
 
 class ChromeAppSortingAppLaunchOrdinal : public ChromeAppSortingTest {
  public:
-  virtual void Initialize() OVERRIDE {
+  virtual void Initialize() override {
     // No extensions yet.
     syncer::StringOrdinal page = syncer::StringOrdinal::CreateInitialOrdinal();
     EXPECT_TRUE(syncer::StringOrdinal::CreateInitialOrdinal().Equals(
         app_sorting()->CreateNextAppLaunchOrdinal(page)));
 
     extension_ = prefs_.AddApp("on_extension_installed");
     EXPECT_FALSE(prefs()->IsExtensionDisabled(extension_->id()));
     prefs()->OnExtensionInstalled(extension_.get(),
                                   Extension::ENABLED,
                                   syncer::StringOrdinal(),
                                   std::string());
   }
 
-  virtual void Verify() OVERRIDE {
+  virtual void Verify() override {
     syncer::StringOrdinal launch_ordinal =
         app_sorting()->GetAppLaunchOrdinal(extension_->id());
     syncer::StringOrdinal page_ordinal =
         syncer::StringOrdinal::CreateInitialOrdinal();
 
     // Extension should have been assigned a valid StringOrdinal.
     EXPECT_TRUE(launch_ordinal.IsValid());
     EXPECT_TRUE(launch_ordinal.LessThan(
         app_sorting()->CreateNextAppLaunchOrdinal(page_ordinal)));
     // Set a new launch ordinal of and verify it comes after.
@@ skipping 21 matching lines @@
         app_sorting()->CreateFirstAppLaunchOrdinal(next_page)));
   }
 
  private:
   scoped_refptr<Extension> extension_;
 };
 TEST_F(ChromeAppSortingAppLaunchOrdinal, ChromeAppSortingAppLaunchOrdinal) {}
 
 class ChromeAppSortingPageOrdinal : public ChromeAppSortingTest {
  public:
-  virtual void Initialize() OVERRIDE {
+  virtual void Initialize() override {
     extension_ = prefs_.AddApp("page_ordinal");
     // Install with a page preference.
     first_page_ = syncer::StringOrdinal::CreateInitialOrdinal();
     prefs()->OnExtensionInstalled(extension_.get(),
                                   Extension::ENABLED,
                                   first_page_,
                                   std::string());
     EXPECT_TRUE(first_page_.Equals(
         app_sorting()->GetPageOrdinal(extension_->id())));
     EXPECT_EQ(0, app_sorting()->PageStringOrdinalAsInteger(first_page_));
 
     scoped_refptr<Extension> extension2 = prefs_.AddApp("page_ordinal_2");
     // Install without any page preference.
     prefs()->OnExtensionInstalled(extension2.get(),
                                   Extension::ENABLED,
                                   syncer::StringOrdinal(),
                                   std::string());
     EXPECT_TRUE(first_page_.Equals(
         app_sorting()->GetPageOrdinal(extension2->id())));
   }
-  virtual void Verify() OVERRIDE {
+  virtual void Verify() override {
     // Set the page ordinal.
     syncer::StringOrdinal new_page = first_page_.CreateAfter();
     app_sorting()->SetPageOrdinal(extension_->id(), new_page);
     // Verify the page ordinal.
     EXPECT_TRUE(
         new_page.Equals(app_sorting()->GetPageOrdinal(extension_->id())));
     EXPECT_EQ(1, app_sorting()->PageStringOrdinalAsInteger(new_page));
 
     // This extension doesn't exist, so it should return an invalid
     // StringOrdinal.
     EXPECT_FALSE(app_sorting()->GetPageOrdinal("foo").IsValid());
   }
 
  private:
   syncer::StringOrdinal first_page_;
   scoped_refptr<Extension> extension_;
 };
 TEST_F(ChromeAppSortingPageOrdinal, ChromeAppSortingPageOrdinal) {}
 
 // Ensure that ChromeAppSorting is able to properly initialize off a set
 // of old page and app launch indices and properly convert them.
 class ChromeAppSortingInitialize : public PrefsPrepopulatedTestBase {
  public:
   ChromeAppSortingInitialize() {}
   virtual ~ChromeAppSortingInitialize() {}
 
-  virtual void Initialize() OVERRIDE {
+  virtual void Initialize() override {
     // A preference determining the order of which the apps appear on the NTP.
     const char kPrefAppLaunchIndexDeprecated[] = "app_launcher_index";
     // A preference determining the page on which an app appears in the NTP.
     const char kPrefPageIndexDeprecated[] = "page_index";
 
     // Setup the deprecated preferences.
     ExtensionScopedPrefs* scoped_prefs =
         static_cast<ExtensionScopedPrefs*>(prefs());
     scoped_prefs->UpdateExtensionPref(extension1()->id(),
                                       kPrefAppLaunchIndexDeprecated,
@@ skipping 18 matching lines @@
 
     // We insert the ids in reserve order so that we have to deal with the
     // element on the 2nd page before the 1st page is seen.
     ExtensionIdList ids;
     ids.push_back(extension3()->id());
     ids.push_back(extension2()->id());
     ids.push_back(extension1()->id());
 
     prefs()->app_sorting()->Initialize(ids);
   }
-  virtual void Verify() OVERRIDE {
+  virtual void Verify() override {
     syncer::StringOrdinal first_ordinal =
         syncer::StringOrdinal::CreateInitialOrdinal();
     AppSorting* app_sorting = prefs()->app_sorting();
 
     EXPECT_TRUE(first_ordinal.Equals(
         app_sorting->GetAppLaunchOrdinal(extension1()->id())));
     EXPECT_TRUE(first_ordinal.LessThan(
         app_sorting->GetAppLaunchOrdinal(extension2()->id())));
     EXPECT_TRUE(first_ordinal.Equals(
         app_sorting->GetAppLaunchOrdinal(extension3()->id())));
 
     EXPECT_TRUE(first_ordinal.Equals(
         app_sorting->GetPageOrdinal(extension1()->id())));
     EXPECT_TRUE(first_ordinal.Equals(
         app_sorting->GetPageOrdinal(extension2()->id())));
     EXPECT_TRUE(first_ordinal.LessThan(
         app_sorting->GetPageOrdinal(extension3()->id())));
   }
 };
 TEST_F(ChromeAppSortingInitialize, ChromeAppSortingInitialize) {}
 
 // Make sure that initialization still works when no extensions are present
 // (i.e. make sure that the web store icon is still loaded into the map).
 class ChromeAppSortingInitializeWithNoApps : public PrefsPrepopulatedTestBase {
  public:
   ChromeAppSortingInitializeWithNoApps() {}
   virtual ~ChromeAppSortingInitializeWithNoApps() {}
 
-  virtual void Initialize() OVERRIDE {
+  virtual void Initialize() override {
     AppSorting* app_sorting = prefs()->app_sorting();
 
     // Make sure that the web store has valid ordinals.
     syncer::StringOrdinal initial_ordinal =
         syncer::StringOrdinal::CreateInitialOrdinal();
     app_sorting->SetPageOrdinal(extensions::kWebStoreAppId,
                                 initial_ordinal);
     app_sorting->SetAppLaunchOrdinal(extensions::kWebStoreAppId,
                                      initial_ordinal);
 
     ExtensionIdList ids;
     app_sorting->Initialize(ids);
   }
-  virtual void Verify() OVERRIDE {
+  virtual void Verify() override {
     ChromeAppSorting* app_sorting =
         static_cast<ChromeAppSorting*>(prefs()->app_sorting());
 
     syncer::StringOrdinal page =
         app_sorting->GetPageOrdinal(extensions::kWebStoreAppId);
     EXPECT_TRUE(page.IsValid());
 
     ChromeAppSorting::PageOrdinalMap::iterator page_it =
         app_sorting->ntp_ordinal_map_.find(page);
     EXPECT_TRUE(page_it != app_sorting->ntp_ordinal_map_.end());
@@ skipping 13 matching lines @@
 // Tests the application index to ordinal migration code for values that
 // shouldn't be converted. This should be removed when the migrate code
 // is taken out.
 // http://crbug.com/107376
 class ChromeAppSortingMigrateAppIndexInvalid
     : public PrefsPrepopulatedTestBase {
  public:
   ChromeAppSortingMigrateAppIndexInvalid() {}
   virtual ~ChromeAppSortingMigrateAppIndexInvalid() {}
 
-  virtual void Initialize() OVERRIDE {
+  virtual void Initialize() override {
     // A preference determining the order of which the apps appear on the NTP.
     const char kPrefAppLaunchIndexDeprecated[] = "app_launcher_index";
     // A preference determining the page on which an app appears in the NTP.
     const char kPrefPageIndexDeprecated[] = "page_index";
 
     // Setup the deprecated preference.
     ExtensionScopedPrefs* scoped_prefs =
         static_cast<ExtensionScopedPrefs*>(prefs());
     scoped_prefs->UpdateExtensionPref(extension1()->id(),
                                       kPrefAppLaunchIndexDeprecated,
                                       new base::FundamentalValue(0));
     scoped_prefs->UpdateExtensionPref(extension1()->id(),
                                       kPrefPageIndexDeprecated,
                                       new base::FundamentalValue(-1));
 
     ExtensionIdList ids;
     ids.push_back(extension1()->id());
 
     prefs()->app_sorting()->Initialize(ids);
   }
-  virtual void Verify() OVERRIDE {
+  virtual void Verify() override {
     // Make sure that the invalid page_index wasn't converted over.
     EXPECT_FALSE(prefs()->app_sorting()->GetAppLaunchOrdinal(
         extension1()->id()).IsValid());
   }
 };
 TEST_F(ChromeAppSortingMigrateAppIndexInvalid,
        ChromeAppSortingMigrateAppIndexInvalid) {}
 
 class ChromeAppSortingFixNTPCollisionsAllCollide
     : public PrefsPrepopulatedTestBase {
  public:
   ChromeAppSortingFixNTPCollisionsAllCollide() {}
   virtual ~ChromeAppSortingFixNTPCollisionsAllCollide() {}
 
-  virtual void Initialize() OVERRIDE {
+  virtual void Initialize() override {
     repeated_ordinal_ = syncer::StringOrdinal::CreateInitialOrdinal();
 
     AppSorting* app_sorting = prefs()->app_sorting();
 
     app_sorting->SetAppLaunchOrdinal(extension1()->id(),
                                      repeated_ordinal_);
     app_sorting->SetPageOrdinal(extension1()->id(), repeated_ordinal_);
 
     app_sorting->SetAppLaunchOrdinal(extension2()->id(), repeated_ordinal_);
     app_sorting->SetPageOrdinal(extension2()->id(), repeated_ordinal_);
 
     app_sorting->SetAppLaunchOrdinal(extension3()->id(), repeated_ordinal_);
     app_sorting->SetPageOrdinal(extension3()->id(), repeated_ordinal_);
 
     app_sorting->FixNTPOrdinalCollisions();
   }
-  virtual void Verify() OVERRIDE {
+  virtual void Verify() override {
     AppSorting* app_sorting = prefs()->app_sorting();
     syncer::StringOrdinal extension1_app_launch =
         app_sorting->GetAppLaunchOrdinal(extension1()->id());
     syncer::StringOrdinal extension2_app_launch =
         app_sorting->GetAppLaunchOrdinal(extension2()->id());
     syncer::StringOrdinal extension3_app_launch =
         app_sorting->GetAppLaunchOrdinal(extension3()->id());
 
     // The overlapping extensions should have be adjusted so that they are
     // sorted by their id.
@@ skipping 18 matching lines @@
 };
 TEST_F(ChromeAppSortingFixNTPCollisionsAllCollide,
        ChromeAppSortingFixNTPCollisionsAllCollide) {}
 
 class ChromeAppSortingFixNTPCollisionsSomeCollideAtStart
     : public PrefsPrepopulatedTestBase {
  public:
   ChromeAppSortingFixNTPCollisionsSomeCollideAtStart() {}
   virtual ~ChromeAppSortingFixNTPCollisionsSomeCollideAtStart() {}
 
-  virtual void Initialize() OVERRIDE {
+  virtual void Initialize() override {
     first_ordinal_ = syncer::StringOrdinal::CreateInitialOrdinal();
     syncer::StringOrdinal second_ordinal = first_ordinal_.CreateAfter();
 
     AppSorting* app_sorting = prefs()->app_sorting();
 
     // Have the first two extension in the same position, with a third
     // (non-colliding) extension after.
 
     app_sorting->SetAppLaunchOrdinal(extension1()->id(), first_ordinal_);
     app_sorting->SetPageOrdinal(extension1()->id(), first_ordinal_);
 
     app_sorting->SetAppLaunchOrdinal(extension2()->id(), first_ordinal_);
     app_sorting->SetPageOrdinal(extension2()->id(), first_ordinal_);
 
     app_sorting->SetAppLaunchOrdinal(extension3()->id(), second_ordinal);
     app_sorting->SetPageOrdinal(extension3()->id(), first_ordinal_);
 
     app_sorting->FixNTPOrdinalCollisions();
   }
-  virtual void Verify() OVERRIDE {
+  virtual void Verify() override {
     AppSorting* app_sorting = prefs()->app_sorting();
     syncer::StringOrdinal extension1_app_launch =
         app_sorting->GetAppLaunchOrdinal(extension1()->id());
     syncer::StringOrdinal extension2_app_launch =
         app_sorting->GetAppLaunchOrdinal(extension2()->id());
     syncer::StringOrdinal extension3_app_launch =
         app_sorting->GetAppLaunchOrdinal(extension3()->id());
 
     // The overlapping extensions should have be adjusted so that they are
     // sorted by their id, but they both should be before ext3, which wasn't
@@ skipping 17 matching lines @@
 };
 TEST_F(ChromeAppSortingFixNTPCollisionsSomeCollideAtStart,
        ChromeAppSortingFixNTPCollisionsSomeCollideAtStart) {}
 
 class ChromeAppSortingFixNTPCollisionsSomeCollideAtEnd
     : public PrefsPrepopulatedTestBase {
  public:
   ChromeAppSortingFixNTPCollisionsSomeCollideAtEnd() {}
   virtual ~ChromeAppSortingFixNTPCollisionsSomeCollideAtEnd() {}
 
-  virtual void Initialize() OVERRIDE {
+  virtual void Initialize() override {
     first_ordinal_ = syncer::StringOrdinal::CreateInitialOrdinal();
     syncer::StringOrdinal second_ordinal = first_ordinal_.CreateAfter();
 
     AppSorting* app_sorting = prefs()->app_sorting();
 
     // Have the first extension in a non-colliding position, followed by two
     // two extension in the same position.
 
     app_sorting->SetAppLaunchOrdinal(extension1()->id(), first_ordinal_);
     app_sorting->SetPageOrdinal(extension1()->id(), first_ordinal_);
 
     app_sorting->SetAppLaunchOrdinal(extension2()->id(), second_ordinal);
     app_sorting->SetPageOrdinal(extension2()->id(), first_ordinal_);
 
     app_sorting->SetAppLaunchOrdinal(extension3()->id(), second_ordinal);
     app_sorting->SetPageOrdinal(extension3()->id(), first_ordinal_);
 
     app_sorting->FixNTPOrdinalCollisions();
   }
-  virtual void Verify() OVERRIDE {
+  virtual void Verify() override {
     AppSorting* app_sorting = prefs()->app_sorting();
     syncer::StringOrdinal extension1_app_launch =
         app_sorting->GetAppLaunchOrdinal(extension1()->id());
     syncer::StringOrdinal extension2_app_launch =
         app_sorting->GetAppLaunchOrdinal(extension2()->id());
     syncer::StringOrdinal extension3_app_launch =
         app_sorting->GetAppLaunchOrdinal(extension3()->id());
 
     // The overlapping extensions should have be adjusted so that they are
     // sorted by their id, but they both should be after ext1, which wasn't
@@ skipping 17 matching lines @@
 };
 TEST_F(ChromeAppSortingFixNTPCollisionsSomeCollideAtEnd,
        ChromeAppSortingFixNTPCollisionsSomeCollideAtEnd) {}
 
 class ChromeAppSortingFixNTPCollisionsTwoCollisions
     : public PrefsPrepopulatedTestBase {
  public:
   ChromeAppSortingFixNTPCollisionsTwoCollisions() {}
   virtual ~ChromeAppSortingFixNTPCollisionsTwoCollisions() {}
 
-  virtual void Initialize() OVERRIDE {
+  virtual void Initialize() override {
     first_ordinal_ = syncer::StringOrdinal::CreateInitialOrdinal();
     syncer::StringOrdinal second_ordinal = first_ordinal_.CreateAfter();
 
     AppSorting* app_sorting = prefs()->app_sorting();
 
     // Have two extensions colliding, followed by two more colliding extensions.
     app_sorting->SetAppLaunchOrdinal(extension1()->id(), first_ordinal_);
     app_sorting->SetPageOrdinal(extension1()->id(), first_ordinal_);
 
     app_sorting->SetAppLaunchOrdinal(extension2()->id(), first_ordinal_);
     app_sorting->SetPageOrdinal(extension2()->id(), first_ordinal_);
 
     app_sorting->SetAppLaunchOrdinal(extension3()->id(), second_ordinal);
     app_sorting->SetPageOrdinal(extension3()->id(), first_ordinal_);
 
     app_sorting->SetAppLaunchOrdinal(extension4()->id(), second_ordinal);
     app_sorting->SetPageOrdinal(extension4()->id(), first_ordinal_);
 
     app_sorting->FixNTPOrdinalCollisions();
   }
-  virtual void Verify() OVERRIDE {
+  virtual void Verify() override {
     AppSorting* app_sorting = prefs()->app_sorting();
     syncer::StringOrdinal extension1_app_launch =
         app_sorting->GetAppLaunchOrdinal(extension1()->id());
     syncer::StringOrdinal extension2_app_launch =
         app_sorting->GetAppLaunchOrdinal(extension2()->id());
     syncer::StringOrdinal extension3_app_launch =
         app_sorting->GetAppLaunchOrdinal(extension3()->id());
     syncer::StringOrdinal extension4_app_launch =
         app_sorting->GetAppLaunchOrdinal(extension4()->id());
 
@@ skipping 26 matching lines @@
 };
 TEST_F(ChromeAppSortingFixNTPCollisionsTwoCollisions,
        ChromeAppSortingFixNTPCollisionsTwoCollisions) {}
 
 class ChromeAppSortingEnsureValidOrdinals
     : public PrefsPrepopulatedTestBase {
  public :
   ChromeAppSortingEnsureValidOrdinals() {}
   virtual ~ChromeAppSortingEnsureValidOrdinals() {}
 
-  virtual void Initialize() OVERRIDE {}
-  virtual void Verify() OVERRIDE {
+  virtual void Initialize() override {}
+  virtual void Verify() override {
     AppSorting* app_sorting = prefs()->app_sorting();
 
     // Give ext1 invalid ordinals and then check that EnsureValidOrdinals fixes
     // them.
     app_sorting->SetAppLaunchOrdinal(extension1()->id(),
                                      syncer::StringOrdinal());
     app_sorting->SetPageOrdinal(extension1()->id(), syncer::StringOrdinal());
 
     app_sorting->EnsureValidOrdinals(extension1()->id(),
                                      syncer::StringOrdinal());
 
     EXPECT_TRUE(app_sorting->GetAppLaunchOrdinal(extension1()->id()).IsValid());
     EXPECT_TRUE(app_sorting->GetPageOrdinal(extension1()->id()).IsValid());
   }
 };
 TEST_F(ChromeAppSortingEnsureValidOrdinals,
        ChromeAppSortingEnsureValidOrdinals) {}
 
 class ChromeAppSortingPageOrdinalMapping : public PrefsPrepopulatedTestBase {
  public:
   ChromeAppSortingPageOrdinalMapping() {}
   virtual ~ChromeAppSortingPageOrdinalMapping() {}
 
-  virtual void Initialize() OVERRIDE {}
-  virtual void Verify() OVERRIDE {
+  virtual void Initialize() override {}
+  virtual void Verify() override {
     std::string ext_1 = "ext_1";
     std::string ext_2 = "ext_2";
 
     ChromeAppSorting* app_sorting =
         static_cast<ChromeAppSorting*>(prefs()->app_sorting());
     syncer::StringOrdinal first_ordinal =
         syncer::StringOrdinal::CreateInitialOrdinal();
 
     // Ensure attempting to removing a mapping with an invalid page doesn't
     // modify the map.
@@ skipping 76 matching lines @@
   scoped_refptr<Extension> app1_scoped_;
   scoped_refptr<Extension> app2_scoped_;
 };
 
 class ChromeAppSortingGetMinOrMaxAppLaunchOrdinalsOnPage
     : public ChromeAppSortingPreinstalledAppsBase {
  public:
   ChromeAppSortingGetMinOrMaxAppLaunchOrdinalsOnPage() {}
   virtual ~ChromeAppSortingGetMinOrMaxAppLaunchOrdinalsOnPage() {}
 
-  virtual void Initialize() OVERRIDE {}
-  virtual void Verify() OVERRIDE {
+  virtual void Initialize() override {}
+  virtual void Verify() override {
     syncer::StringOrdinal page = syncer::StringOrdinal::CreateInitialOrdinal();
     ChromeAppSorting* app_sorting =
         static_cast<ChromeAppSorting*>(prefs()->app_sorting());
 
     syncer::StringOrdinal min =
         app_sorting->GetMinOrMaxAppLaunchOrdinalsOnPage(
             page,
             ChromeAppSorting::MIN_ORDINAL);
     syncer::StringOrdinal max =
         app_sorting->GetMinOrMaxAppLaunchOrdinalsOnPage(
@@ skipping 23 matching lines @@
        ChromeAppSortingGetMinOrMaxAppLaunchOrdinalsOnPage) {}
 
 // Make sure that empty pages aren't removed from the integer to ordinal
 // mapping. See http://crbug.com/109802 for details.
 class ChromeAppSortingKeepEmptyStringOrdinalPages
     : public ChromeAppSortingPreinstalledAppsBase {
  public:
   ChromeAppSortingKeepEmptyStringOrdinalPages() {}
   virtual ~ChromeAppSortingKeepEmptyStringOrdinalPages() {}
 
-  virtual void Initialize() OVERRIDE {
+  virtual void Initialize() override {
     AppSorting* app_sorting = prefs()->app_sorting();
 
     syncer::StringOrdinal first_page =
         syncer::StringOrdinal::CreateInitialOrdinal();
     app_sorting->SetPageOrdinal(app1_->id(), first_page);
     EXPECT_EQ(0, app_sorting->PageStringOrdinalAsInteger(first_page));
 
     last_page_ = first_page.CreateAfter();
     app_sorting->SetPageOrdinal(app2_->id(), last_page_);
     EXPECT_EQ(1, app_sorting->PageStringOrdinalAsInteger(last_page_));
 
     // Move the second app to create an empty page.
     app_sorting->SetPageOrdinal(app2_->id(), first_page);
     EXPECT_EQ(0, app_sorting->PageStringOrdinalAsInteger(first_page));
   }
-  virtual void Verify() OVERRIDE {
+  virtual void Verify() override {
     AppSorting* app_sorting = prefs()->app_sorting();
 
     // Move the second app to a new empty page at the end, skipping over
     // the current empty page.
     last_page_ = last_page_.CreateAfter();
     app_sorting->SetPageOrdinal(app2_->id(), last_page_);
     EXPECT_EQ(2, app_sorting->PageStringOrdinalAsInteger(last_page_));
     EXPECT_TRUE(last_page_.Equals(app_sorting->PageIntegerAsStringOrdinal(2)));
   }
 
  private:
   syncer::StringOrdinal last_page_;
 };
 TEST_F(ChromeAppSortingKeepEmptyStringOrdinalPages,
        ChromeAppSortingKeepEmptyStringOrdinalPages) {}
 
 class ChromeAppSortingMakesFillerOrdinals
     : public ChromeAppSortingPreinstalledAppsBase {
  public:
   ChromeAppSortingMakesFillerOrdinals() {}
   virtual ~ChromeAppSortingMakesFillerOrdinals() {}
 
-  virtual void Initialize() OVERRIDE {
+  virtual void Initialize() override {
     AppSorting* app_sorting = prefs()->app_sorting();
 
     syncer::StringOrdinal first_page =
         syncer::StringOrdinal::CreateInitialOrdinal();
     app_sorting->SetPageOrdinal(app1_->id(), first_page);
     EXPECT_EQ(0, app_sorting->PageStringOrdinalAsInteger(first_page));
   }
-  virtual void Verify() OVERRIDE {
+  virtual void Verify() override {
     AppSorting* app_sorting = prefs()->app_sorting();
 
     // Because the UI can add an unlimited number of empty pages without an app
     // on them, this test simulates dropping of an app on the 1st and 4th empty
     // pages (3rd and 6th pages by index) to ensure we don't crash and that
     // filler ordinals are created as needed. See: http://crbug.com/122214
     syncer::StringOrdinal page_three =
         app_sorting->PageIntegerAsStringOrdinal(2);
     app_sorting->SetPageOrdinal(app1_->id(), page_three);
     EXPECT_EQ(2, app_sorting->PageStringOrdinalAsInteger(page_three));
 
     syncer::StringOrdinal page_six = app_sorting->PageIntegerAsStringOrdinal(5);
     app_sorting->SetPageOrdinal(app1_->id(), page_six);
     EXPECT_EQ(5, app_sorting->PageStringOrdinalAsInteger(page_six));
   }
 };
 TEST_F(ChromeAppSortingMakesFillerOrdinals,
        ChromeAppSortingMakesFillerOrdinals) {}
 
 class ChromeAppSortingDefaultOrdinalsBase : public ChromeAppSortingTest {
  public:
   ChromeAppSortingDefaultOrdinalsBase() {}
   virtual ~ChromeAppSortingDefaultOrdinalsBase() {}
 
-  virtual void Initialize() OVERRIDE {
+  virtual void Initialize() override {
     app_ = CreateApp("app");
 
     InitDefaultOrdinals();
     ChromeAppSorting* app_sorting =
         static_cast<ChromeAppSorting*>(prefs()->app_sorting());
     ChromeAppSorting::AppOrdinalsMap& sorting_defaults =
         app_sorting->default_ordinals_;
     sorting_defaults[app_->id()].page_ordinal = default_page_ordinal_;
     sorting_defaults[app_->id()].app_launch_ordinal =
         default_app_launch_ordinal_;
@@ skipping 40 matching lines @@
   syncer::StringOrdinal default_app_launch_ordinal_;
 };
 
 // Tests that the app gets its default ordinals.
 class ChromeAppSortingDefaultOrdinals
     : public ChromeAppSortingDefaultOrdinalsBase {
  public:
   ChromeAppSortingDefaultOrdinals() {}
   virtual ~ChromeAppSortingDefaultOrdinals() {}
 
-  virtual void Verify() OVERRIDE {
+  virtual void Verify() override {
     AppSorting* app_sorting = prefs()->app_sorting();
     EXPECT_TRUE(app_sorting->GetPageOrdinal(app_->id()).Equals(
         default_page_ordinal_));
     EXPECT_TRUE(app_sorting->GetAppLaunchOrdinal(app_->id()).Equals(
         default_app_launch_ordinal_));
   }
 };
 TEST_F(ChromeAppSortingDefaultOrdinals,
        ChromeAppSortingDefaultOrdinals) {}
 
 // Tests that the default page ordinal is overridden by install page ordinal.
 class ChromeAppSortingDefaultOrdinalOverriddenByInstallPage
     : public ChromeAppSortingDefaultOrdinalsBase {
  public:
   ChromeAppSortingDefaultOrdinalOverriddenByInstallPage() {}
   virtual ~ChromeAppSortingDefaultOrdinalOverriddenByInstallPage() {}
 
-  virtual void Verify() OVERRIDE {
+  virtual void Verify() override {
     AppSorting* app_sorting = prefs()->app_sorting();
 
     EXPECT_FALSE(app_sorting->GetPageOrdinal(app_->id()).Equals(
         default_page_ordinal_));
     EXPECT_TRUE(app_sorting->GetPageOrdinal(app_->id()).Equals(install_page_));
   }
 
  protected:
-  virtual void InstallApps() OVERRIDE {
+  virtual void InstallApps() override {
     install_page_ = default_page_ordinal_.CreateAfter();
     prefs()->OnExtensionInstalled(app_.get(),
                                   Extension::ENABLED,
                                   install_page_,
                                   std::string());
   }
 
  private:
   syncer::StringOrdinal install_page_;
 };
 TEST_F(ChromeAppSortingDefaultOrdinalOverriddenByInstallPage,
        ChromeAppSortingDefaultOrdinalOverriddenByInstallPage) {}
 
 // Tests that the default ordinals are overridden by user values.
 class ChromeAppSortingDefaultOrdinalOverriddenByUserValue
     : public ChromeAppSortingDefaultOrdinalsBase {
  public:
   ChromeAppSortingDefaultOrdinalOverriddenByUserValue() {}
   virtual ~ChromeAppSortingDefaultOrdinalOverriddenByUserValue() {}
 
-  virtual void Verify() OVERRIDE {
+  virtual void Verify() override {
     AppSorting* app_sorting = prefs()->app_sorting();
 
     EXPECT_TRUE(app_sorting->GetPageOrdinal(app_->id()).Equals(
         user_page_ordinal_));
     EXPECT_TRUE(app_sorting->GetAppLaunchOrdinal(app_->id()).Equals(
         user_app_launch_ordinal_));
   }
 
  protected:
-  virtual void SetupUserOrdinals() OVERRIDE {
+  virtual void SetupUserOrdinals() override {
     user_page_ordinal_ = default_page_ordinal_.CreateAfter();
     user_app_launch_ordinal_ = default_app_launch_ordinal_.CreateBefore();
 
     AppSorting* app_sorting = prefs()->app_sorting();
     app_sorting->SetPageOrdinal(app_->id(), user_page_ordinal_);
     app_sorting->SetAppLaunchOrdinal(app_->id(), user_app_launch_ordinal_);
   }
 
  private:
   syncer::StringOrdinal user_page_ordinal_;
   syncer::StringOrdinal user_app_launch_ordinal_;
 };
 TEST_F(ChromeAppSortingDefaultOrdinalOverriddenByUserValue,
        ChromeAppSortingDefaultOrdinalOverriddenByUserValue) {}
 
 // Tests that the default app launch ordinal is changed to avoid collision.
 class ChromeAppSortingDefaultOrdinalNoCollision
     : public ChromeAppSortingDefaultOrdinalsBase {
  public:
   ChromeAppSortingDefaultOrdinalNoCollision() {}
   virtual ~ChromeAppSortingDefaultOrdinalNoCollision() {}
 
-  virtual void Verify() OVERRIDE {
+  virtual void Verify() override {
     AppSorting* app_sorting = prefs()->app_sorting();
 
     // Use the default page.
     EXPECT_TRUE(app_sorting->GetPageOrdinal(app_->id()).Equals(
         default_page_ordinal_));
     // Not using the default app launch ordinal because of the collision.
     EXPECT_FALSE(app_sorting->GetAppLaunchOrdinal(app_->id()).Equals(
         default_app_launch_ordinal_));
   }
 
  protected:
-  virtual void SetupUserOrdinals() OVERRIDE {
+  virtual void SetupUserOrdinals() override {
     other_app_ = prefs_.AddApp("other_app");
     // Creates a collision.
     AppSorting* app_sorting = prefs()->app_sorting();
     app_sorting->SetPageOrdinal(other_app_->id(), default_page_ordinal_);
     app_sorting->SetAppLaunchOrdinal(other_app_->id(),
                                      default_app_launch_ordinal_);
 
     yet_another_app_ = prefs_.AddApp("yet_aother_app");
     app_sorting->SetPageOrdinal(yet_another_app_->id(), default_page_ordinal_);
     app_sorting->SetAppLaunchOrdinal(yet_another_app_->id(),
                                      default_app_launch_ordinal_);
   }
 
  private:
   scoped_refptr<Extension> other_app_;
   scoped_refptr<Extension> yet_another_app_;
 };
 TEST_F(ChromeAppSortingDefaultOrdinalNoCollision,
        ChromeAppSortingDefaultOrdinalNoCollision) {}
 
 // Tests that SetExtensionVisible() correctly hides and unhides extensions.
 class ChromeAppSortingSetExtensionVisible : public ChromeAppSortingTest {
  public:
   ChromeAppSortingSetExtensionVisible() {}
   virtual ~ChromeAppSortingSetExtensionVisible() {}
 
-  virtual void Initialize() OVERRIDE {
+  virtual void Initialize() override {
     first_app_ = prefs_.AddApp("first_app");
     second_app_ = prefs_.AddApp("second_app");
   }
 
-  virtual void Verify() OVERRIDE {
+  virtual void Verify() override {
     ChromeAppSorting* sorting = app_sorting();
     syncer::StringOrdinal page1 = sorting->GetPageOrdinal(first_app_->id());
     syncer::StringOrdinal page2 = sorting->GetPageOrdinal(second_app_->id());
     EXPECT_TRUE(sorting->GetAppLaunchOrdinal(first_app_->id()).IsValid());
     EXPECT_TRUE(sorting->GetAppLaunchOrdinal(second_app_->id()).IsValid());
     EXPECT_TRUE(page1.IsValid());
     EXPECT_TRUE(page2.IsValid());
     EXPECT_TRUE(page1.Equals(page2));
 
     sorting->SetExtensionVisible(first_app_->id(), false);
     EXPECT_EQ(
         1U, sorting->CountItemsVisibleOnNtp(sorting->ntp_ordinal_map_[page1]));
 
     sorting->SetExtensionVisible(first_app_->id(), true);
     EXPECT_EQ(
         2U, sorting->CountItemsVisibleOnNtp(sorting->ntp_ordinal_map_[page1]));
   }
 
  private:
   scoped_refptr<Extension> first_app_;
   scoped_refptr<Extension> second_app_;
 };
 TEST_F(ChromeAppSortingSetExtensionVisible,
        ChromeAppSortingSetExtensionVisible) {
 }
 
 }  // namespace extensions