Standardize usage of virtual/override/final in chrome/browser/media_galleries

chrome/browser/media_galleries/fileapi/itunes_data_provider_browsertest.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 <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
@@ skipping 36 matching lines @@
 
 }  // namespace
 
 class TestITunesDataProvider : public ITunesDataProvider {
  public:
   TestITunesDataProvider(const base::FilePath& xml_library_path,
                          const base::Closure& callback)
       : ITunesDataProvider(xml_library_path),
         callback_(callback) {
   }
-  virtual ~TestITunesDataProvider() {}
+  ~TestITunesDataProvider() override {}
 
  private:
-  virtual void OnLibraryChanged(const base::FilePath& path,
-                                bool error) override {
+  void OnLibraryChanged(const base::FilePath& path, bool error) override {
     ITunesDataProvider::OnLibraryChanged(path, error);
     callback_.Run();
   }
 
   base::Closure callback_;
 
   DISALLOW_COPY_AND_ASSIGN(TestITunesDataProvider);
 };
 
 class ITunesDataProviderTest : public InProcessBrowserTest {
@@ skipping 138 matching lines @@
   base::Closure quit_closure_;
 
   DISALLOW_COPY_AND_ASSIGN(ITunesDataProviderTest);
 };
 
 class ITunesDataProviderBasicTest : public ITunesDataProviderTest {
  public:
   ITunesDataProviderBasicTest() {}
   virtual ~ITunesDataProviderBasicTest() {}
 
-  virtual std::vector<LibraryEntry> SetUpLibrary() override {
+  std::vector<LibraryEntry> SetUpLibrary() override {
     base::FilePath track = library_dir().AppendASCII("Track.mp3");
     std::vector<LibraryEntry> entries;
     entries.push_back(LibraryEntry("Artist", "Album", track));
     return entries;
   }
 
-  virtual void StartTest(bool parse_success) override {
+  void StartTest(bool parse_success) override {
     EXPECT_TRUE(parse_success);
 
     // KnownArtist
     EXPECT_TRUE(data_provider()->KnownArtist("Artist"));
     EXPECT_FALSE(data_provider()->KnownArtist("Artist2"));
 
     // KnownAlbum
     EXPECT_TRUE(data_provider()->KnownAlbum("Artist", "Album"));
     EXPECT_FALSE(data_provider()->KnownAlbum("Artist", "Album2"));
     EXPECT_FALSE(data_provider()->KnownAlbum("Artist2", "Album"));
@@ skipping 40 matching lines @@
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ITunesDataProviderBasicTest);
 };
 
 class ITunesDataProviderRefreshTest : public ITunesDataProviderTest {
  public:
   ITunesDataProviderRefreshTest() {}
   virtual ~ITunesDataProviderRefreshTest() {}
 
-  virtual std::vector<LibraryEntry> SetUpLibrary() override {
+  std::vector<LibraryEntry> SetUpLibrary() override {
     base::FilePath track = library_dir().AppendASCII("Track.mp3");
     std::vector<LibraryEntry> entries;
     entries.push_back(LibraryEntry("Artist", "Album", track));
     return entries;
   }
 
-  virtual void StartTest(bool parse_success) override {
+  void StartTest(bool parse_success) override {
     EXPECT_TRUE(parse_success);
 
     // Initial contents.
     ExpectTrackLocation("Artist", "Album", "Track.mp3");
     ExpectNoTrack("Artist2", "Album2", "Track2.mp3");
 
     // New file.
     base::FilePath track2 = library_dir().AppendASCII("Track2.mp3");
     std::vector<LibraryEntry> entries;
     entries.push_back(LibraryEntry("Artist2", "Album2", track2));
@@ skipping 22 matching lines @@
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ITunesDataProviderRefreshTest);
 };
 
 class ITunesDataProviderInvalidTest : public ITunesDataProviderTest {
  public:
   ITunesDataProviderInvalidTest() {}
   virtual ~ITunesDataProviderInvalidTest() {}
 
-  virtual std::vector<LibraryEntry> SetUpLibrary() override {
+  std::vector<LibraryEntry> SetUpLibrary() override {
     base::FilePath track = library_dir().AppendASCII("Track.mp3");
     std::vector<LibraryEntry> entries;
     entries.push_back(LibraryEntry("Artist", "Album", track));
     return entries;
   }
 
-  virtual void StartTest(bool parse_success) override {
+  void StartTest(bool parse_success) override {
     EXPECT_TRUE(parse_success);
 
     SetLibraryChangeCallback(
         base::Bind(&ITunesDataProvider::RefreshData,
                    base::Unretained(data_provider()),
                    base::Bind(&ITunesDataProviderInvalidTest::CheckInvalid,
                               base::Unretained(this))));
     ASSERT_EQ(1L, base::WriteFile(XmlFile(), " ", 1));
   }
 
   void CheckInvalid(bool is_valid) {
     EXPECT_FALSE(is_valid);
     TestDone();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ITunesDataProviderInvalidTest);
 };
 
 class ITunesDataProviderUniqueNameTest : public ITunesDataProviderTest {
  public:
   ITunesDataProviderUniqueNameTest() {}
   virtual ~ITunesDataProviderUniqueNameTest() {}
 
-  virtual std::vector<LibraryEntry> SetUpLibrary() override {
+  std::vector<LibraryEntry> SetUpLibrary() override {
     base::FilePath track = library_dir().AppendASCII("Track.mp3");
     std::vector<LibraryEntry> entries;
     // Dupe album names should get uniquified with the track id, which in the
     // test framework is the vector index.
     entries.push_back(LibraryEntry("Artist", "Album", track));
     entries.push_back(LibraryEntry("Artist", "Album", track));
     entries.push_back(LibraryEntry("Artist", "Album2", track));
     return entries;
   }
 
-  virtual void StartTest(bool parse_success) override {
+  void StartTest(bool parse_success) override {
     EXPECT_TRUE(parse_success);
 
     base::FilePath track =
         library_dir().AppendASCII("Track.mp3").NormalizePathSeparators();
     EXPECT_EQ(track.value(),
               data_provider()->GetTrackLocation(
                   "Artist", "Album",
                   "Track (1).mp3").NormalizePathSeparators().value());
     EXPECT_EQ(track.value(),
               data_provider()->GetTrackLocation(
@@ skipping 12 matching lines @@
 };
 
 class ITunesDataProviderEscapeTest : public ITunesDataProviderTest {
  // Albums and tracks that aren't the same, but become the same after
  // replacing bad characters are not handled properly, but that case should
  // never happen in practice.
  public:
   ITunesDataProviderEscapeTest() {}
   virtual ~ITunesDataProviderEscapeTest() {}
 
-  virtual std::vector<LibraryEntry> SetUpLibrary() override {
+  std::vector<LibraryEntry> SetUpLibrary() override {
     base::FilePath track = library_dir().AppendASCII("Track:1.mp3");
     std::vector<LibraryEntry> entries;
     entries.push_back(LibraryEntry("Artist:/name", "Album:name/", track));
     entries.push_back(LibraryEntry("Artist/name", "Album:name", track));
     entries.push_back(LibraryEntry("Artist/name", "Album:name", track));
     entries.push_back(LibraryEntry(kDeNormalizedName, kNormalizedName, track));
     return entries;
   }
 
-  virtual void StartTest(bool parse_success) override {
+  void StartTest(bool parse_success) override {
     EXPECT_TRUE(parse_success);
 
     base::FilePath track =
         library_dir().AppendASCII("Track:1.mp3").NormalizePathSeparators();
     EXPECT_EQ(track.value(),
               data_provider()->GetTrackLocation(
                   "Artist__name", "Album_name_",
                   "Track_1.mp3").NormalizePathSeparators().value());
     EXPECT_EQ(track.value(),
               data_provider()->GetTrackLocation(
@@ skipping 29 matching lines @@
 
 IN_PROC_BROWSER_TEST_F(ITunesDataProviderUniqueNameTest, UniqueNameTest) {
   RunTest();
 }
 
 IN_PROC_BROWSER_TEST_F(ITunesDataProviderEscapeTest, EscapeTest) {
   RunTest();
 }
 
 }  // namespace itunes