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

chrome/browser/sync/sessions/sessions_sync_manager_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 "chrome/browser/sync/sessions/sessions_sync_manager.h"
 
 #include "base/strings/string_util.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/sessions/session_tab_helper.h"
 #include "chrome/browser/sessions/session_types.h"
@@ skipping 32 matching lines @@
 
 namespace browser_sync {
 
 namespace {
 
 class SyncedWindowDelegateOverride : public SyncedWindowDelegate {
  public:
   explicit SyncedWindowDelegateOverride(SyncedWindowDelegate* wrapped)
       : wrapped_(wrapped) {
   }
-  virtual ~SyncedWindowDelegateOverride() {}
+  ~SyncedWindowDelegateOverride() override {}
 
-  virtual bool HasWindow() const override {
-    return wrapped_->HasWindow();
-  }
+  bool HasWindow() const override { return wrapped_->HasWindow(); }
 
-  virtual SessionID::id_type GetSessionId() const override {
+  SessionID::id_type GetSessionId() const override {
     return wrapped_->GetSessionId();
   }
 
-  virtual int GetTabCount() const override {
-    return wrapped_->GetTabCount();
-  }
+  int GetTabCount() const override { return wrapped_->GetTabCount(); }
 
-  virtual int GetActiveIndex() const override {
-    return wrapped_->GetActiveIndex();
-  }
+  int GetActiveIndex() const override { return wrapped_->GetActiveIndex(); }
 
-  virtual bool IsApp() const override {
-    return wrapped_->IsApp();
-  }
+  bool IsApp() const override { return wrapped_->IsApp(); }
 
-  virtual bool IsTypeTabbed() const override {
-    return wrapped_->IsTypeTabbed();
-  }
+  bool IsTypeTabbed() const override { return wrapped_->IsTypeTabbed(); }
 
-  virtual bool IsTypePopup() const override {
-    return wrapped_->IsTypePopup();
-  }
+  bool IsTypePopup() const override { return wrapped_->IsTypePopup(); }
 
-  virtual bool IsTabPinned(const SyncedTabDelegate* tab) const override {
+  bool IsTabPinned(const SyncedTabDelegate* tab) const override {
     return wrapped_->IsTabPinned(tab);
   }
 
-  virtual SyncedTabDelegate* GetTabAt(int index) const override {
+  SyncedTabDelegate* GetTabAt(int index) const override {
     if (tab_overrides_.find(index) != tab_overrides_.end())
       return tab_overrides_.find(index)->second;
 
     return wrapped_->GetTabAt(index);
   }
 
   void OverrideTabAt(int index,
                      SyncedTabDelegate* delegate,
                      SessionID::id_type tab_id) {
     tab_overrides_[index] = delegate;
     tab_id_overrides_[index] = tab_id;
   }
 
-  virtual SessionID::id_type GetTabIdAt(int index) const override {
+  SessionID::id_type GetTabIdAt(int index) const override {
     if (tab_id_overrides_.find(index) != tab_id_overrides_.end())
       return tab_id_overrides_.find(index)->second;
     return wrapped_->GetTabIdAt(index);
   }
 
-  virtual bool IsSessionRestoreInProgress() const override {
+  bool IsSessionRestoreInProgress() const override {
     return wrapped_->IsSessionRestoreInProgress();
   }
 
  private:
   std::map<int, SyncedTabDelegate*> tab_overrides_;
   std::map<int, SessionID::id_type> tab_id_overrides_;
   SyncedWindowDelegate* wrapped_;
 };
 
 class TestSyncedWindowDelegatesGetter : public SyncedWindowDelegatesGetter {
  public:
   TestSyncedWindowDelegatesGetter(
       const std::set<SyncedWindowDelegate*>& delegates)
       : delegates_(delegates) {}
 
-  virtual const std::set<SyncedWindowDelegate*> GetSyncedWindowDelegates()
-      override {
+  const std::set<SyncedWindowDelegate*> GetSyncedWindowDelegates() override {
     return delegates_;
   }
  private:
   const std::set<SyncedWindowDelegate*> delegates_;
 };
 
 class TestSyncProcessorStub : public syncer::SyncChangeProcessor {
  public:
   explicit TestSyncProcessorStub(syncer::SyncChangeList* output)
       : output_(output) {}
-  virtual syncer::SyncError ProcessSyncChanges(
+  syncer::SyncError ProcessSyncChanges(
       const tracked_objects::Location& from_here,
       const syncer::SyncChangeList& change_list) override {
     if (error_.IsSet()) {
       syncer::SyncError error = error_;
       error_ = syncer::SyncError();
       return error;
     }
 
     if (output_)
       output_->insert(output_->end(), change_list.begin(), change_list.end());
 
     return syncer::SyncError();
   }
 
-  virtual syncer::SyncDataList GetAllSyncData(syncer::ModelType type)
-      const override {
+  syncer::SyncDataList GetAllSyncData(syncer::ModelType type) const override {
     return sync_data_to_return_;
   }
 
   void FailProcessSyncChangesWith(const syncer::SyncError& error) {
     error_ = error;
   }
 
   void SetSyncDataToReturn(const syncer::SyncDataList& data) {
     sync_data_to_return_ = data;
   }
@@ skipping 51 matching lines @@
         i + 2,
         entity,
         base::Time(),
         syncer::AttachmentIdList(),
         syncer::AttachmentServiceProxyForTest::Create()));
   }
 }
 
 class DummyRouter : public LocalSessionEventRouter {
  public:
-  virtual ~DummyRouter() {}
-  virtual void StartRoutingTo(LocalSessionEventHandler* handler) override {}
-  virtual void Stop() override {}
+  ~DummyRouter() override {}
+  void StartRoutingTo(LocalSessionEventHandler* handler) override {}
+  void Stop() override {}
 };
 
 scoped_ptr<LocalSessionEventRouter> NewDummyRouter() {
   return scoped_ptr<LocalSessionEventRouter>(new DummyRouter());
 }
 
 }  // namespace
 
 class SessionsSyncManagerTest
     : public BrowserWithTestWindowTest {
@@ skipping 121 matching lines @@
 
 namespace {
 
 class SyncedTabDelegateFake : public SyncedTabDelegate {
  public:
   SyncedTabDelegateFake() : current_entry_index_(0),
                             pending_entry_index_(-1),
                             is_supervised_(false),
                             sync_id_(-1),
                             blocked_navigations_(NULL) {}
-  virtual ~SyncedTabDelegateFake() {}
+  ~SyncedTabDelegateFake() override {}
 
-  virtual int GetCurrentEntryIndex() const override {
-    return current_entry_index_;
-  }
+  int GetCurrentEntryIndex() const override { return current_entry_index_; }
   void set_current_entry_index(int i) {
     current_entry_index_ = i;
   }
 
-  virtual content::NavigationEntry* GetEntryAtIndex(int i) const override {
+  content::NavigationEntry* GetEntryAtIndex(int i) const override {
     const int size = entries_.size();
     return (size < i + 1) ? NULL : entries_[i];
   }
 
   void AppendEntry(content::NavigationEntry* entry) {
     entries_.push_back(entry);
   }
 
-  virtual int GetEntryCount() const override {
-    return entries_.size();
-  }
+  int GetEntryCount() const override { return entries_.size(); }
 
-  virtual int GetPendingEntryIndex() const override {
-    return pending_entry_index_;
-  }
+  int GetPendingEntryIndex() const override { return pending_entry_index_; }
   void set_pending_entry_index(int i) {
     pending_entry_index_ = i;
   }
 
-  virtual SessionID::id_type GetWindowId() const override {
+  SessionID::id_type GetWindowId() const override {
     return SessionID::id_type();
   }
 
-  virtual SessionID::id_type GetSessionId() const override {
+  SessionID::id_type GetSessionId() const override {
     return SessionID::id_type();
   }
 
-  virtual bool IsBeingDestroyed() const override { return false; }
-  virtual Profile* profile() const override { return NULL; }
-  virtual std::string GetExtensionAppId() const override {
-    return std::string();
-  }
-  virtual content::NavigationEntry* GetPendingEntry() const override {
-   return NULL;
-  }
-  virtual content::NavigationEntry* GetActiveEntry() const override {
-   return NULL;
-  }
-  virtual bool ProfileIsSupervised() const override {
-   return is_supervised_;
-  }
+  bool IsBeingDestroyed() const override { return false; }
+  Profile* profile() const override { return NULL; }
+  std::string GetExtensionAppId() const override { return std::string(); }
+  content::NavigationEntry* GetPendingEntry() const override { return NULL; }
+  content::NavigationEntry* GetActiveEntry() const override { return NULL; }
+  bool ProfileIsSupervised() const override { return is_supervised_; }
   void set_is_supervised(bool is_supervised) { is_supervised_ = is_supervised; }
-  virtual const std::vector<const content::NavigationEntry*>*
-      GetBlockedNavigations() const override {
+  const std::vector<const content::NavigationEntry*>* GetBlockedNavigations()
+      const override {
     return blocked_navigations_;
   }
   void set_blocked_navigations(
       std::vector<const content::NavigationEntry*>* navs) {
     blocked_navigations_ = navs;
   }
-  virtual bool IsPinned() const override {
-   return false;
-  }
-  virtual bool HasWebContents() const override {
-   return false;
-  }
-  virtual content::WebContents* GetWebContents() const override {
-   return NULL;
-  }
+  bool IsPinned() const override { return false; }
+  bool HasWebContents() const override { return false; }
+  content::WebContents* GetWebContents() const override { return NULL; }
 
   // Session sync related methods.
-  virtual int GetSyncId() const override {
-   return sync_id_;
-  }
-  virtual void SetSyncId(int sync_id) override {
-    sync_id_ = sync_id;
-  }
+  int GetSyncId() const override { return sync_id_; }
+  void SetSyncId(int sync_id) override { sync_id_ = sync_id; }
 
   void reset() {
     current_entry_index_ = 0;
     pending_entry_index_ = -1;
     sync_id_ = -1;
     entries_.clear();
   }
 
  private:
    int current_entry_index_;
@@ skipping 1377 matching lines @@
 namespace {
 class SessionNotificationObserver : public content::NotificationObserver {
  public:
   SessionNotificationObserver() : notified_of_update_(false),
                                   notified_of_refresh_(false) {
     registrar_.Add(this, chrome::NOTIFICATION_FOREIGN_SESSION_UPDATED,
                    content::NotificationService::AllSources());
     registrar_.Add(this, chrome::NOTIFICATION_SYNC_REFRESH_LOCAL,
                    content::NotificationService::AllSources());
   }
-  virtual void Observe(int type,
-                       const content::NotificationSource& source,
-                       const content::NotificationDetails& details) override {
+  void Observe(int type,
+               const content::NotificationSource& source,
+               const content::NotificationDetails& details) override {
     switch (type) {
       case chrome::NOTIFICATION_FOREIGN_SESSION_UPDATED:
         notified_of_update_ = true;
         break;
       case chrome::NOTIFICATION_SYNC_REFRESH_LOCAL:
         notified_of_refresh_ = true;
         break;
       default:
         NOTREACHED();
         break;
@@ skipping 147 matching lines @@
         base::Time(),
         syncer::AttachmentIdList(),
         syncer::AttachmentServiceProxyForTest::Create()));
   }
 
   syncer::SyncChangeList output;
   InitWithSyncDataTakeOutput(initial_data, &output);
 }
 
 }  // namespace browser_sync