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

chrome/browser/media_galleries/fileapi/picasa_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 <set>
 #include <string>
 #include <vector>
 
 #include "base/bind_helpers.h"
 #include "base/files/file_path.h"
@@ skipping 174 matching lines @@
 
 class TestPicasaFileUtil : public PicasaFileUtil {
  public:
   TestPicasaFileUtil(MediaPathFilter* media_path_filter,
                      PicasaDataProvider* data_provider)
       : PicasaFileUtil(media_path_filter),
         data_provider_(data_provider) {
   }
   virtual ~TestPicasaFileUtil() {}
  private:
-  virtual PicasaDataProvider* GetDataProvider() OVERRIDE {
+  virtual PicasaDataProvider* GetDataProvider() override {
     return data_provider_;
   }
 
   PicasaDataProvider* data_provider_;
 };
 
 class TestMediaFileSystemBackend : public MediaFileSystemBackend {
  public:
   TestMediaFileSystemBackend(const base::FilePath& profile_path,
                              PicasaFileUtil* picasa_file_util)
       : MediaFileSystemBackend(profile_path,
                                MediaFileSystemBackend::MediaTaskRunner().get()),
         test_file_util_(picasa_file_util) {}
 
   virtual storage::AsyncFileUtil* GetAsyncFileUtil(
-      storage::FileSystemType type) OVERRIDE {
+      storage::FileSystemType type) override {
     if (type != storage::kFileSystemTypePicasa)
       return NULL;
 
     return test_file_util_.get();
   }
 
  private:
   scoped_ptr<storage::AsyncFileUtil> test_file_util_;
 };
 
 class PicasaFileUtilTest : public testing::Test {
  public:
   PicasaFileUtilTest()
       : io_thread_(content::BrowserThread::IO, &message_loop_) {
   }
   virtual ~PicasaFileUtilTest() {}
 
-  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();
 
     SynchronouslyRunOnMediaTaskRunner(base::Bind(
         &PicasaFileUtilTest::SetUpOnMediaTaskRunner, base::Unretained(this)));
 
     media_path_filter_.reset(new MediaPathFilter());
 
     ScopedVector<storage::FileSystemBackend> additional_providers;
     additional_providers.push_back(new TestMediaFileSystemBackend(
         profile_dir_.path(),
         new TestPicasaFileUtil(media_path_filter_.get(),
                                picasa_data_provider_.get())));
 
     file_system_context_ = new storage::FileSystemContext(
         base::MessageLoopProxy::current().get(),
         base::MessageLoopProxy::current().get(),
         storage::ExternalMountPoints::CreateRefCounted().get(),
         storage_policy.get(),
         NULL,
         additional_providers.Pass(),
         std::vector<storage::URLRequestAutoMountHandler>(),
         profile_dir_.path(),
         content::CreateAllowFileAccessOptions());
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     SynchronouslyRunOnMediaTaskRunner(
         base::Bind(&PicasaFileUtilTest::TearDownOnMediaTaskRunner,
                    base::Unretained(this)));
   }
 
  protected:
   void SetUpOnMediaTaskRunner() {
     picasa_data_provider_.reset(new PicasaDataProvider(base::FilePath()));
   }
 
@@ skipping 322 matching lines @@
   operation_runner()->CreateSnapshotFile(
       CreateURL(std::string(kPicasaDirAlbums) +
                 "/albumname 2013-04-16/mapped_name.jpg"),
       snapshot_callback);
   loop.Run();
   EXPECT_EQ(base::File::FILE_OK, error);
   EXPECT_EQ(image_path, platform_path_result);
 }
 
 }  // namespace picasa