Standardize usage of virtual/override/final in sync/

sync/internal_api/attachments/attachment_service_impl_unittest.cc

 // Copyright 2014 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 "sync/internal_api/public/attachments/attachment_service_impl.h"
 
 #include "base/bind.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/timer/mock_timer.h"
 #include "sync/internal_api/public/attachments/fake_attachment_downloader.h"
 #include "sync/internal_api/public/attachments/fake_attachment_uploader.h"
 #include "testing/gmock/include/gmock/gmock-matchers.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace syncer {
 
 namespace {
 
 class MockAttachmentStore : public AttachmentStore,
                             public base::SupportsWeakPtr<MockAttachmentStore> {
  public:
   MockAttachmentStore() {}
 
-  virtual void Read(const AttachmentIdList& ids,
-                    const ReadCallback& callback) override {
+  void Read(const AttachmentIdList& ids,
+            const ReadCallback& callback) override {
     read_ids.push_back(ids);
     read_callbacks.push_back(callback);
   }
 
-  virtual void Write(const AttachmentList& attachments,
-                     const WriteCallback& callback) override {
+  void Write(const AttachmentList& attachments,
+             const WriteCallback& callback) override {
     write_attachments.push_back(attachments);
     write_callbacks.push_back(callback);
   }
 
-  virtual void Drop(const AttachmentIdList& ids,
-                    const DropCallback& callback) override {
+  void Drop(const AttachmentIdList& ids,
+            const DropCallback& callback) override {
     NOTREACHED();
   }
 
   // Respond to Read request. Attachments found in local_attachments should be
   // returned, everything else should be reported unavailable.
   void RespondToRead(const AttachmentIdSet& local_attachments) {
     scoped_refptr<base::RefCountedString> data = new base::RefCountedString();
     ReadCallback callback = read_callbacks.back();
     AttachmentIdList ids = read_ids.back();
     read_callbacks.pop_back();
@@ skipping 31 matching lines @@
     base::MessageLoop::current()->PostTask(FROM_HERE,
                                            base::Bind(callback, result));
   }
 
   std::vector<AttachmentIdList> read_ids;
   std::vector<ReadCallback> read_callbacks;
   std::vector<AttachmentList> write_attachments;
   std::vector<WriteCallback> write_callbacks;
 
  private:
-  virtual ~MockAttachmentStore() {}
+  ~MockAttachmentStore() override {}
 
   DISALLOW_COPY_AND_ASSIGN(MockAttachmentStore);
 };
 
 class MockAttachmentDownloader
     : public AttachmentDownloader,
       public base::SupportsWeakPtr<MockAttachmentDownloader> {
  public:
   MockAttachmentDownloader() {}
 
-  virtual void DownloadAttachment(const AttachmentId& id,
-                                  const DownloadCallback& callback) override {
+  void DownloadAttachment(const AttachmentId& id,
+                          const DownloadCallback& callback) override {
     ASSERT_TRUE(download_requests.find(id) == download_requests.end());
     download_requests.insert(std::make_pair(id, callback));
   }
 
   // Multiple requests to download will be active at the same time.
   // RespondToDownload should respond to only one of them.
   void RespondToDownload(const AttachmentId& id, const DownloadResult& result) {
     ASSERT_TRUE(download_requests.find(id) != download_requests.end());
     scoped_ptr<Attachment> attachment;
     if (result == DOWNLOAD_SUCCESS) {
@@ skipping 12 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(MockAttachmentDownloader);
 };
 
 class MockAttachmentUploader
     : public AttachmentUploader,
       public base::SupportsWeakPtr<MockAttachmentUploader> {
  public:
   MockAttachmentUploader() {}
 
   // AttachmentUploader implementation.
-  virtual void UploadAttachment(const Attachment& attachment,
-                                const UploadCallback& callback) override {
+  void UploadAttachment(const Attachment& attachment,
+                        const UploadCallback& callback) override {
     const AttachmentId id = attachment.GetId();
     ASSERT_TRUE(upload_requests.find(id) == upload_requests.end());
     upload_requests.insert(std::make_pair(id, callback));
   }
 
   void RespondToUpload(const AttachmentId& id, const UploadResult& result) {
     ASSERT_TRUE(upload_requests.find(id) != upload_requests.end());
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(upload_requests[id], result, id));
     upload_requests.erase(id);
@@ skipping 19 matching lines @@
   }
 
   virtual void TearDown() override {
     attachment_service_.reset();
     ASSERT_FALSE(attachment_store_);
     ASSERT_FALSE(attachment_uploader_);
     ASSERT_FALSE(attachment_downloader_);
   }
 
   // AttachmentService::Delegate implementation.
-  virtual void OnAttachmentUploaded(
-      const AttachmentId& attachment_id) override {
+  void OnAttachmentUploaded(const AttachmentId& attachment_id) override {
     on_attachment_uploaded_list_.push_back(attachment_id);
   }
 
   void InitializeAttachmentService(
       scoped_ptr<MockAttachmentUploader> uploader,
       scoped_ptr<MockAttachmentDownloader> downloader,
       AttachmentService::Delegate* delegate) {
     scoped_refptr<MockAttachmentStore> attachment_store(
         new MockAttachmentStore());
     attachment_store_ = attachment_store->AsWeakPtr();
@@ skipping 360 matching lines @@
   net::NetworkChangeNotifier::NotifyObserversOfNetworkChangeForTests(
       net::NetworkChangeNotifier::CONNECTION_WIFI);
   RunLoop();
 
   // No longer in backoff.
   ASSERT_TRUE(mock_timer()->IsRunning());
   ASSERT_EQ(base::TimeDelta(), mock_timer()->GetCurrentDelay());
 }
 
 }  // namespace syncer