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

chrome/browser/chromeos/drive/job_scheduler_unittest.cc

 // Copyright (c) 2012 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/chromeos/drive/job_scheduler.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
@@ skipping 53 matching lines @@
 
   // Gets the progress event information of the specified type.
   void GetProgressInfo(JobType job_type, std::vector<int64>* progress) {
     for (size_t i = 0; i < events.size(); ++i) {
       if (events[i].type == UPDATED && events[i].info.job_type == job_type)
         progress->push_back(events[i].info.num_completed_bytes);
     }
   }
 
   // JobListObserver overrides.
-  virtual void OnJobAdded(const JobInfo& info) OVERRIDE {
+  virtual void OnJobAdded(const JobInfo& info) override {
     events.push_back(EventLog(ADDED, info));
   }
 
-  virtual void OnJobUpdated(const JobInfo& info) OVERRIDE {
+  virtual void OnJobUpdated(const JobInfo& info) override {
     events.push_back(EventLog(UPDATED, info));
   }
 
-  virtual void OnJobDone(const JobInfo& info, FileError error) OVERRIDE {
+  virtual void OnJobDone(const JobInfo& info, FileError error) override {
     events.push_back(EventLog(DONE, info));
   }
 
  private:
   std::vector<EventLog> events;
 };
 
 // Fake drive service extended for testing cancellation.
 // When upload_new_file_cancelable is set, this Drive service starts
 // returning a closure to cancel from InitiateUploadNewFile(). The task will
 // finish only when the cancel closure is called.
 class CancelTestableFakeDriveService : public FakeDriveService {
  public:
   CancelTestableFakeDriveService()
       : upload_new_file_cancelable_(false) {
   }
 
   void set_upload_new_file_cancelable(bool cancelable) {
     upload_new_file_cancelable_ = cancelable;
   }
 
   virtual google_apis::CancelCallback InitiateUploadNewFile(
       const std::string& content_type,
       int64 content_length,
       const std::string& parent_resource_id,
       const std::string& title,
       const InitiateUploadNewFileOptions& options,
-      const google_apis::InitiateUploadCallback& callback) OVERRIDE {
+      const google_apis::InitiateUploadCallback& callback) override {
     if (upload_new_file_cancelable_)
       return base::Bind(callback, google_apis::GDATA_CANCELLED, GURL());
 
     return FakeDriveService::InitiateUploadNewFile(content_type,
                                                    content_length,
                                                    parent_resource_id,
                                                    title,
                                                    options,
                                                    callback);
   }
 
  private:
   bool upload_new_file_cancelable_;
 };
 
 }  // namespace
 
 class JobSchedulerTest : public testing::Test {
  public:
   JobSchedulerTest()
       : pref_service_(new TestingPrefServiceSimple) {
     test_util::RegisterDrivePrefs(pref_service_->registry());
   }
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     fake_network_change_notifier_.reset(
         new test_util::FakeNetworkChangeNotifier);
 
     logger_.reset(new EventLogger);
 
     fake_drive_service_.reset(new CancelTestableFakeDriveService);
     test_util::SetUpTestEntries(fake_drive_service_.get());
     fake_drive_service_->LoadAppListForDriveApi("drive/applist.json");
 
     scheduler_.reset(new JobScheduler(pref_service_.get(),
@@ skipping 905 matching lines @@
   scheduler_->CancelJob(first_job_id);
 
   // Only the first job should be cancelled.
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(google_apis::GDATA_CANCELLED, error1);
   EXPECT_EQ(google_apis::HTTP_SUCCESS, error2);
   EXPECT_TRUE(scheduler_->GetJobInfoList().empty());
 }
 
 }  // namespace drive