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

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 57 matching lines @@
   int64 received_bytes() const { return received_bytes_; }
   void set_received_bytes(int64 received_bytes) {
     received_bytes_ = received_bytes;
   }
 
   int64 resume_upload_call_count() const { return resume_upload_call_count_; }
 
  private:
   // DriveServiceInterface overrides.
   // Handles a request for obtaining an upload location URL.
-  virtual CancelCallback InitiateUploadNewFile(
+  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 {
     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(
+  CancelCallback InitiateUploadExistingFile(
       const std::string& content_type,
       int64 content_length,
       const std::string& resource_id,
       const InitiateUploadExistingFileOptions& options,
       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(
+  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 {
     // The upload range should start from the current first unreceived byte.
     EXPECT_EQ(received_bytes_, start_position);
@@ skipping 23 matching lines @@
       int64 chunk_size = end_position - start_position;
       base::MessageLoop::current()->PostTask(FROM_HERE,
           base::Bind(progress_callback, chunk_size, chunk_size));
     }
 
     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 {
+  CancelCallback GetUploadStatus(const GURL& upload_location,
+                                 int64 content_length,
+                                 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 21 matching lines @@
 
   const base::FilePath expected_upload_file_;
   const int64 expected_content_length_;
   int64 received_bytes_;
   int64 resume_upload_call_count_;
 };
 
 // Mock DriveService that returns a failure at InitiateUpload().
 class MockDriveServiceNoConnectionAtInitiate : public DummyDriveService {
   // Returns error.
-  virtual CancelCallback InitiateUploadNewFile(
+  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 {
     base::MessageLoop::current()->PostTask(FROM_HERE,
         base::Bind(callback, GDATA_NO_CONNECTION, GURL()));
     return CancelCallback();
   }
 
-  virtual CancelCallback InitiateUploadExistingFile(
+  CancelCallback InitiateUploadExistingFile(
       const std::string& content_type,
       int64 content_length,
       const std::string& resource_id,
       const InitiateUploadExistingFileOptions& options,
       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(
+  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 {
     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(
+  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 {
     base::MessageLoop::current()->PostTask(FROM_HERE,
         base::Bind(callback, HTTP_SUCCESS, GURL(kTestUploadNewFileURL)));
     return CancelCallback();
   }
 
-  virtual CancelCallback InitiateUploadExistingFile(
+  CancelCallback InitiateUploadExistingFile(
       const std::string& content_type,
       int64 content_length,
       const std::string& resource_id,
       const InitiateUploadExistingFileOptions& options,
       const InitiateUploadCallback& callback) override {
     base::MessageLoop::current()->PostTask(FROM_HERE,
         base::Bind(callback, HTTP_SUCCESS, GURL(kTestUploadExistingFileURL)));
     return CancelCallback();
   }
 
   // Returns error.
-  virtual CancelCallback ResumeUpload(
+  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 {
     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 {
+  CancelCallback GetUploadStatus(const GURL& upload_url,
+                                 int64 content_length,
+                                 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:
@@ skipping 270 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