replace OVERRIDE and FINAL with override and final in chrome/browser/[a-i]*

chrome/browser/drive/drive_uploader_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/drive/drive_uploader.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 63 matching lines @@
 
  private:
   // DriveServiceInterface overrides.
   // Handles a request for obtaining an upload location URL.
   virtual CancelCallback InitiateUploadNewFile(
       const std::string& content_type,
       int64 content_length,
       const std::string& parent_resource_id,
       const std::string& title,
       const InitiateUploadNewFileOptions& options,
-      const InitiateUploadCallback& callback) OVERRIDE {
+      const InitiateUploadCallback& callback) override {
     EXPECT_EQ(kTestDocumentTitle, title);
     EXPECT_EQ(kTestMimeType, content_type);
     EXPECT_EQ(expected_content_length_, content_length);
     EXPECT_EQ(kTestInitiateUploadParentResourceId, parent_resource_id);
 
     // Calls back the upload URL for subsequent ResumeUpload requests.
     // InitiateUpload is an asynchronous function, so don't callback directly.
     base::MessageLoop::current()->PostTask(FROM_HERE,
         base::Bind(callback, HTTP_SUCCESS, GURL(kTestUploadNewFileURL)));
     return CancelCallback();
   }
 
   virtual CancelCallback InitiateUploadExistingFile(
       const std::string& content_type,
       int64 content_length,
       const std::string& resource_id,
       const InitiateUploadExistingFileOptions& options,
-      const InitiateUploadCallback& callback) OVERRIDE {
+      const InitiateUploadCallback& callback) override {
     EXPECT_EQ(kTestMimeType, content_type);
     EXPECT_EQ(expected_content_length_, content_length);
     EXPECT_EQ(kTestInitiateUploadResourceId, resource_id);
 
     if (!options.etag.empty() && options.etag != kTestETag) {
       base::MessageLoop::current()->PostTask(FROM_HERE,
           base::Bind(callback, HTTP_PRECONDITION, GURL()));
       return CancelCallback();
     }
 
     // Calls back the upload URL for subsequent ResumeUpload requests.
     // InitiateUpload is an asynchronous function, so don't callback directly.
     base::MessageLoop::current()->PostTask(FROM_HERE,
         base::Bind(callback, HTTP_SUCCESS, GURL(kTestUploadExistingFileURL)));
     return CancelCallback();
   }
 
   // Handles a request for uploading a chunk of bytes.
   virtual CancelCallback ResumeUpload(
       const GURL& upload_location,
       int64 start_position,
       int64 end_position,
       int64 content_length,
       const std::string& content_type,
       const base::FilePath& local_file_path,
       const UploadRangeCallback& callback,
-      const ProgressCallback& progress_callback) OVERRIDE {
+      const ProgressCallback& progress_callback) override {
     // The upload range should start from the current first unreceived byte.
     EXPECT_EQ(received_bytes_, start_position);
     EXPECT_EQ(expected_upload_file_, local_file_path);
 
     // The upload data must be split into 512KB chunks.
     const int64 expected_chunk_end =
         std::min(received_bytes_ + kUploadChunkSize, expected_content_length_);
     EXPECT_EQ(expected_chunk_end, end_position);
 
     // The upload URL returned by InitiateUpload() must be used.
@@ skipping 18 matching lines @@
     }
 
     SendUploadRangeResponse(upload_location, callback);
     return CancelCallback();
   }
 
   // Handles a request to fetch the current upload status.
   virtual CancelCallback GetUploadStatus(
       const GURL& upload_location,
       int64 content_length,
-      const UploadRangeCallback& callback) OVERRIDE {
+      const UploadRangeCallback& callback) override {
     EXPECT_EQ(expected_content_length_, content_length);
     // The upload URL returned by InitiateUpload() must be used.
     EXPECT_TRUE(GURL(kTestUploadNewFileURL) == upload_location ||
                 GURL(kTestUploadExistingFileURL) == upload_location);
 
     SendUploadRangeResponse(upload_location, callback);
     return CancelCallback();
   }
 
   // Runs |callback| with the current upload status.
@@ skipping 27 matching lines @@
 
 // Mock DriveService that returns a failure at InitiateUpload().
 class MockDriveServiceNoConnectionAtInitiate : public DummyDriveService {
   // Returns error.
   virtual CancelCallback InitiateUploadNewFile(
       const std::string& content_type,
       int64 content_length,
       const std::string& parent_resource_id,
       const std::string& title,
       const InitiateUploadNewFileOptions& options,
-      const InitiateUploadCallback& callback) OVERRIDE {
+      const InitiateUploadCallback& callback) override {
     base::MessageLoop::current()->PostTask(FROM_HERE,
         base::Bind(callback, GDATA_NO_CONNECTION, GURL()));
     return CancelCallback();
   }
 
   virtual CancelCallback InitiateUploadExistingFile(
       const std::string& content_type,
       int64 content_length,
       const std::string& resource_id,
       const InitiateUploadExistingFileOptions& options,
-      const InitiateUploadCallback& callback) OVERRIDE {
+      const InitiateUploadCallback& callback) override {
     base::MessageLoop::current()->PostTask(FROM_HERE,
         base::Bind(callback, GDATA_NO_CONNECTION, GURL()));
     return CancelCallback();
   }
 
   // Should not be used.
   virtual CancelCallback ResumeUpload(
       const GURL& upload_url,
       int64 start_position,
       int64 end_position,
       int64 content_length,
       const std::string& content_type,
       const base::FilePath& local_file_path,
       const UploadRangeCallback& callback,
-      const ProgressCallback& progress_callback) OVERRIDE {
+      const ProgressCallback& progress_callback) override {
     NOTREACHED();
     return CancelCallback();
   }
 };
 
 // Mock DriveService that returns a failure at ResumeUpload().
 class MockDriveServiceNoConnectionAtResume : public DummyDriveService {
   // Succeeds and returns an upload location URL.
   virtual CancelCallback InitiateUploadNewFile(
       const std::string& content_type,
       int64 content_length,
       const std::string& parent_resource_id,
       const std::string& title,
       const InitiateUploadNewFileOptions& options,
-      const InitiateUploadCallback& callback) OVERRIDE {
+      const InitiateUploadCallback& callback) override {
     base::MessageLoop::current()->PostTask(FROM_HERE,
         base::Bind(callback, HTTP_SUCCESS, GURL(kTestUploadNewFileURL)));
     return CancelCallback();
   }
 
   virtual CancelCallback InitiateUploadExistingFile(
       const std::string& content_type,
       int64 content_length,
       const std::string& resource_id,
       const InitiateUploadExistingFileOptions& options,
-      const InitiateUploadCallback& callback) OVERRIDE {
+      const InitiateUploadCallback& callback) override {
     base::MessageLoop::current()->PostTask(FROM_HERE,
         base::Bind(callback, HTTP_SUCCESS, GURL(kTestUploadExistingFileURL)));
     return CancelCallback();
   }
 
   // Returns error.
   virtual CancelCallback ResumeUpload(
       const GURL& upload_url,
       int64 start_position,
       int64 end_position,
       int64 content_length,
       const std::string& content_type,
       const base::FilePath& local_file_path,
       const UploadRangeCallback& callback,
-      const ProgressCallback& progress_callback) OVERRIDE {
+      const ProgressCallback& progress_callback) override {
     base::MessageLoop::current()->PostTask(FROM_HERE,
         base::Bind(callback,
                    UploadRangeResponse(GDATA_NO_CONNECTION, -1, -1),
                    base::Passed(scoped_ptr<FileResource>())));
     return CancelCallback();
   }
 };
 
 // Mock DriveService that returns a failure at GetUploadStatus().
 class MockDriveServiceNoConnectionAtGetUploadStatus : public DummyDriveService {
   // Returns error.
   virtual CancelCallback GetUploadStatus(
       const GURL& upload_url,
       int64 content_length,
-      const UploadRangeCallback& callback) OVERRIDE {
+      const UploadRangeCallback& callback) override {
     base::MessageLoop::current()->PostTask(FROM_HERE,
         base::Bind(callback,
                    UploadRangeResponse(GDATA_NO_CONNECTION, -1, -1),
                    base::Passed(scoped_ptr<FileResource>())));
     return CancelCallback();
   }
 };
 
 class DriveUploaderTest : public testing::Test {
  public:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
   }
 
  protected:
   content::TestBrowserThreadBundle thread_bundle_;
   base::ScopedTempDir temp_dir_;
 };
 
 }  // namespace
 
@@ skipping 259 matching lines @@
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_TRUE(upload_location.is_empty());
   ASSERT_TRUE(entry);
   EXPECT_EQ(kTestDummyMd5, entry->md5_checksum());
   ASSERT_EQ(1U, upload_progress_values.size());
   EXPECT_EQ(test_util::ProgressInfo(1024 * 1024, 1024 * 1024),
             upload_progress_values[0]);
 }
 
 }  // namespace drive