replace OVERRIDE and FINAL with override and final in chrome/browser/[j-q]*

chrome/browser/media_galleries/fileapi/iphoto_file_util_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 <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 57 matching lines @@
 
 class TestIPhotoDataProvider : public IPhotoDataProvider {
  public:
   explicit TestIPhotoDataProvider(const base::FilePath& fake_library_path)
      : IPhotoDataProvider(fake_library_path) {
     EXPECT_TRUE(fake_auto_add_dir_.CreateUniqueTempDir());
   }
 
   virtual ~TestIPhotoDataProvider() {}
 
-  virtual void RefreshData(const ReadyCallback& ready_callback) OVERRIDE {
+  virtual void RefreshData(const ReadyCallback& ready_callback) override {
     ready_callback.Run(true /* success */);
   }
 
-  virtual std::vector<std::string> GetAlbumNames() const OVERRIDE {
+  virtual std::vector<std::string> GetAlbumNames() const override {
     std::vector<std::string> names;
     names.push_back("Album1");
     names.push_back("has_originals");
     return names;
   }
 
   virtual std::map<std::string, base::FilePath> GetAlbumContents(
-      const std::string& album) const OVERRIDE {
+      const std::string& album) const override {
     std::map<std::string, base::FilePath> contents;
     contents["a.jpg"] = library_path().AppendASCII("a.jpg");
     return contents;
   }
 
   virtual base::FilePath GetPhotoLocationInAlbum(
       const std::string& album,
-      const std::string& filename) const OVERRIDE {
+      const std::string& filename) const override {
     return library_path().AppendASCII("a.jpg");
   }
 
-  virtual bool HasOriginals(const std::string& album) const OVERRIDE {
+  virtual bool HasOriginals(const std::string& album) const override {
     return (album == "has_originals");
   }
 
   virtual std::map<std::string, base::FilePath> GetOriginals(
-      const std::string& album) const OVERRIDE {
+      const std::string& album) const override {
     std::map<std::string, base::FilePath> contents;
     contents["a.jpg"] = library_path().AppendASCII("orig.jpg");
     return contents;
   }
 
   virtual base::FilePath GetOriginalPhotoLocation(
       const std::string& album,
-      const std::string& filename) const OVERRIDE {
+      const std::string& filename) const override {
     return library_path().AppendASCII("orig.jpg");
   }
 
  private:
   base::ScopedTempDir fake_auto_add_dir_;
 };
 
 class TestIPhotoFileUtil : public IPhotoFileUtil {
  public:
   explicit TestIPhotoFileUtil(MediaPathFilter* media_path_filter,
                               IPhotoDataProvider* data_provider)
       : IPhotoFileUtil(media_path_filter),
         data_provider_(data_provider) {
   }
   virtual ~TestIPhotoFileUtil() {}
 
  private:
-  virtual IPhotoDataProvider* GetDataProvider() OVERRIDE {
+  virtual IPhotoDataProvider* GetDataProvider() override {
     return data_provider_;
   }
 
   IPhotoDataProvider* data_provider_;
 };
 
 class TestMediaFileSystemBackend : public MediaFileSystemBackend {
  public:
   TestMediaFileSystemBackend(const base::FilePath& profile_path,
                              IPhotoFileUtil* iphoto_file_util)
       : MediaFileSystemBackend(
             profile_path,
             MediaFileSystemBackend::MediaTaskRunner().get()),
         test_file_util_(iphoto_file_util) {}
 
   virtual storage::AsyncFileUtil* GetAsyncFileUtil(
-      storage::FileSystemType type) OVERRIDE {
+      storage::FileSystemType type) override {
     if (type != storage::kFileSystemTypeIphoto)
       return NULL;
 
     return test_file_util_.get();
   }
 
  private:
   scoped_ptr<storage::AsyncFileUtil> test_file_util_;
 };
 
@@ skipping 16 matching lines @@
         0,
         base::WriteFile(
             fake_library_dir_.path().AppendASCII("orig.jpg"),
             NULL,
             0));
 
     iphoto_data_provider_.reset(
         new TestIPhotoDataProvider(fake_library_dir_.path()));
   }
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     ASSERT_TRUE(profile_dir_.CreateUniqueTempDir());
     ImportedMediaGalleryRegistry::GetInstance()->Initialize();
 
     scoped_refptr<storage::SpecialStoragePolicy> storage_policy =
         new content::MockSpecialStoragePolicy();
 
     // Initialize fake IPhotoDataProvider on media task runner thread.
     MediaFileSystemBackend::MediaTaskRunner()->PostTask(
         FROM_HERE,
         base::Bind(&IPhotoFileUtilTest::SetUpDataProvider,
@@ skipping 147 matching lines @@
   completed = false;
   ReadDirectoryTestHelper(operation_runner(), url, &contents, &completed);
   ASSERT_TRUE(completed);
   ASSERT_EQ(1u, contents.size());
 
   EXPECT_FALSE(contents.front().is_directory);
   EXPECT_EQ("a.jpg", contents.front().name);
 }
 
 }  // namespace iphoto