replace OVERRIDE and FINAL with override and 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 {
+                    const ReadCallback& callback) override {
     read_ids.push_back(ids);
     read_callbacks.push_back(callback);
   }
 
   virtual void Write(const AttachmentList& attachments,
-                     const WriteCallback& callback) OVERRIDE {
+                     const WriteCallback& callback) override {
     write_attachments.push_back(attachments);
     write_callbacks.push_back(callback);
   }
 
   virtual void Drop(const AttachmentIdList& ids,
-                    const DropCallback& callback) OVERRIDE {
+                    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 43 matching lines @@
   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 {
+                                  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 13 matching lines @@
 };
 
 class MockAttachmentUploader
     : public AttachmentUploader,
       public base::SupportsWeakPtr<MockAttachmentUploader> {
  public:
   MockAttachmentUploader() {}
 
   // AttachmentUploader implementation.
   virtual void UploadAttachment(const Attachment& attachment,
-                                const UploadCallback& callback) OVERRIDE {
+                                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);
   }
 
   std::map<AttachmentId, UploadCallback> upload_requests;
 
   DISALLOW_COPY_AND_ASSIGN(MockAttachmentUploader);
 };
 
 }  // namespace
 
 class AttachmentServiceImplTest : public testing::Test,
                                   public AttachmentService::Delegate {
  protected:
   AttachmentServiceImplTest() {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     network_change_notifier_.reset(net::NetworkChangeNotifier::CreateMock());
     InitializeAttachmentService(make_scoped_ptr(new MockAttachmentUploader()),
                                 make_scoped_ptr(new MockAttachmentDownloader()),
                                 this);
   }
 
-  virtual void TearDown() OVERRIDE {
+  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 {
+      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