Standardize usage of virtual/override/final in sync/

sync/sessions/model_type_registry.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/sessions/model_type_registry.h"
 
 #include "base/bind.h"
 #include "base/observer_list.h"
 #include "base/thread_task_runner_handle.h"
 #include "sync/engine/directory_commit_contributor.h"
 #include "sync/engine/directory_update_handler.h"
 #include "sync/engine/model_type_sync_proxy.h"
 #include "sync/engine/model_type_sync_proxy_impl.h"
 #include "sync/engine/model_type_sync_worker.h"
 #include "sync/engine/model_type_sync_worker_impl.h"
 #include "sync/internal_api/public/non_blocking_sync_common.h"
 #include "sync/sessions/directory_type_debug_info_emitter.h"
 #include "sync/util/cryptographer.h"
 
 namespace syncer {
 
 namespace {
 
 class ModelTypeSyncProxyWrapper : public ModelTypeSyncProxy {
  public:
   ModelTypeSyncProxyWrapper(
       const base::WeakPtr<ModelTypeSyncProxyImpl>& proxy,
       const scoped_refptr<base::SequencedTaskRunner>& processor_task_runner);
-  virtual ~ModelTypeSyncProxyWrapper();
+  ~ModelTypeSyncProxyWrapper() override;
 
-  virtual void OnCommitCompleted(
-      const DataTypeState& type_state,
-      const CommitResponseDataList& response_list) override;
-  virtual void OnUpdateReceived(
-      const DataTypeState& type_state,
-      const UpdateResponseDataList& response_list,
-      const UpdateResponseDataList& pending_updates) override;
+  void OnCommitCompleted(const DataTypeState& type_state,
+                         const CommitResponseDataList& response_list) override;
+  void OnUpdateReceived(const DataTypeState& type_state,
+                        const UpdateResponseDataList& response_list,
+                        const UpdateResponseDataList& pending_updates) override;
 
  private:
   base::WeakPtr<ModelTypeSyncProxyImpl> processor_;
   scoped_refptr<base::SequencedTaskRunner> processor_task_runner_;
 };
 
 ModelTypeSyncProxyWrapper::ModelTypeSyncProxyWrapper(
     const base::WeakPtr<ModelTypeSyncProxyImpl>& proxy,
     const scoped_refptr<base::SequencedTaskRunner>& processor_task_runner)
     : processor_(proxy), processor_task_runner_(processor_task_runner) {
@@ skipping 24 matching lines @@
                  type_state,
                  response_list,
                  pending_updates));
 }
 
 class ModelTypeSyncWorkerWrapper : public ModelTypeSyncWorker {
  public:
   ModelTypeSyncWorkerWrapper(
       const base::WeakPtr<ModelTypeSyncWorkerImpl>& worker,
       const scoped_refptr<base::SequencedTaskRunner>& sync_thread);
-  virtual ~ModelTypeSyncWorkerWrapper();
+  ~ModelTypeSyncWorkerWrapper() override;
 
-  virtual void EnqueueForCommit(const CommitRequestDataList& list) override;
+  void EnqueueForCommit(const CommitRequestDataList& list) override;
 
  private:
   base::WeakPtr<ModelTypeSyncWorkerImpl> worker_;
   scoped_refptr<base::SequencedTaskRunner> sync_thread_;
 };
 
 ModelTypeSyncWorkerWrapper::ModelTypeSyncWorkerWrapper(
     const base::WeakPtr<ModelTypeSyncWorkerImpl>& worker,
     const scoped_refptr<base::SequencedTaskRunner>& sync_thread)
     : worker_(worker), sync_thread_(sync_thread) {
@@ skipping 261 matching lines @@
   for (ScopedVector<ModelTypeSyncWorkerImpl>::const_iterator it =
            model_type_sync_workers_.begin();
        it != model_type_sync_workers_.end();
        ++it) {
     enabled_off_thread_types.Put((*it)->GetModelType());
   }
   return enabled_off_thread_types;
 }
 
 }  // namespace syncer