replace OVERRIDE and FINAL with override and final in components/

components/sync_driver/generic_change_processor_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 "components/sync_driver/generic_change_processor.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
@@ skipping 23 matching lines @@
 
 namespace {
 
 // A mock that keeps track of attachments passed to UploadAttachments.
 class MockAttachmentService : public syncer::AttachmentServiceImpl {
  public:
   MockAttachmentService(
       const scoped_refptr<syncer::AttachmentStore>& attachment_store);
   virtual ~MockAttachmentService();
   virtual void UploadAttachments(
-      const syncer::AttachmentIdSet& attachment_ids) OVERRIDE;
+      const syncer::AttachmentIdSet& attachment_ids) override;
   std::vector<syncer::AttachmentIdSet>* attachment_id_sets();
 
  private:
   std::vector<syncer::AttachmentIdSet> attachment_id_sets_;
 };
 
 MockAttachmentService::MockAttachmentService(
     const scoped_refptr<syncer::AttachmentStore>& attachment_store)
     : AttachmentServiceImpl(attachment_store,
                             scoped_ptr<syncer::AttachmentUploader>(
@@ skipping 21 matching lines @@
 
 // MockSyncApiComponentFactory needed to initialize GenericChangeProcessor and
 // pass MockAttachmentService to it.
 class MockSyncApiComponentFactory : public SyncApiComponentFactory {
  public:
   MockSyncApiComponentFactory(
       scoped_ptr<syncer::AttachmentService> attachment_service)
       : attachment_service_(attachment_service.Pass()) {}
 
   virtual base::WeakPtr<syncer::SyncableService> GetSyncableServiceForType(
-      syncer::ModelType type) OVERRIDE {
+      syncer::ModelType type) override {
     // Shouldn't be called for this test.
     NOTREACHED();
     return base::WeakPtr<syncer::SyncableService>();
   }
 
   virtual scoped_ptr<syncer::AttachmentService> CreateAttachmentService(
       const scoped_refptr<syncer::AttachmentStore>& attachment_store,
       const syncer::UserShare& user_share,
-      syncer::AttachmentService::Delegate* delegate) OVERRIDE {
+      syncer::AttachmentService::Delegate* delegate) override {
     EXPECT_TRUE(attachment_service_ != NULL);
     return attachment_service_.Pass();
   }
 
  private:
   scoped_ptr<syncer::AttachmentService> attachment_service_;
 };
 
 class SyncGenericChangeProcessorTest : public testing::Test {
  public:
   // Most test cases will use this type.  For those that need a
   // GenericChangeProcessor for a different type, use |InitializeForType|.
   static const syncer::ModelType kType = syncer::PREFERENCES;
 
   SyncGenericChangeProcessorTest()
       : syncable_service_ptr_factory_(&fake_syncable_service_),
         mock_attachment_service_(NULL) {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     // Use kType by default, but allow test cases to re-initialize with whatever
     // type they choose.  Therefore, it's important that all type dependent
     // initialization occurs in InitializeForType.
     InitializeForType(kType);
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     mock_attachment_service_ = NULL;
     if (test_user_share_) {
       test_user_share_->TearDown();
     }
   }
 
   // Initialize GenericChangeProcessor and related classes for testing with
   // model type |type|.
   void InitializeForType(syncer::ModelType type) {
     TearDown();
@@ skipping 344 matching lines @@
   // AttachmentService to upload id1 only.
   ConstructGenericChangeProcessor(kType);
   ASSERT_EQ(1U, mock_attachment_service()->attachment_id_sets()->size());
   ASSERT_THAT(mock_attachment_service()->attachment_id_sets()->front(),
               testing::UnorderedElementsAre(id1));
 }
 
 }  // namespace
 
 }  // namespace sync_driver