Using override keyword in ObjectVisitor class hierarchy.

src/profiler/heap-snapshot-generator.cc

 // Copyright 2013 the V8 project 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 "src/profiler/heap-snapshot-generator.h"
 
 #include "src/code-stubs.h"
 #include "src/conversions.h"
 #include "src/debug/debug.h"
 #include "src/profiler/allocation-tracker.h"
@@ skipping 977 matching lines @@
 class IndexedReferencesExtractor : public ObjectVisitor {
  public:
   IndexedReferencesExtractor(V8HeapExplorer* generator,
                              HeapObject* parent_obj,
                              int parent)
       : generator_(generator),
         parent_obj_(parent_obj),
         parent_(parent),
         next_index_(0) {
   }
-  void VisitCodeEntry(Address entry_address) {
+  void VisitCodeEntry(Address entry_address) override {
      Code* code = Code::cast(Code::GetObjectFromEntryAddress(entry_address));
      generator_->SetInternalReference(parent_obj_, parent_, "code", code);
      generator_->TagCodeObject(code);
   }
-  void VisitPointers(Object** start, Object** end) {
+  void VisitPointers(Object** start, Object** end) override {
     for (Object** p = start; p < end; p++) {
       ++next_index_;
       if (CheckVisitedAndUnmark(p)) continue;
       generator_->SetHiddenReference(parent_obj_, parent_, next_index_, *p);
     }
   }
   static void MarkVisitedField(HeapObject* obj, int offset) {
     if (offset < 0) return;
     Address field = obj->address() + offset;
     DCHECK(Memory::Object_at(field)->IsHeapObject());
@@ skipping 748 matching lines @@
     VisitorSynchronization::SyncTag tag;
   };
 
  public:
   explicit RootsReferencesExtractor(Heap* heap)
       : collecting_all_references_(false),
         previous_reference_count_(0),
         heap_(heap) {
   }
 
-  void VisitPointers(Object** start, Object** end) {
+  void VisitPointers(Object** start, Object** end) override {
     if (collecting_all_references_) {
       for (Object** p = start; p < end; p++) all_references_.Add(*p);
     } else {
       for (Object** p = start; p < end; p++) strong_references_.Add(*p);
     }
   }
 
   void SetCollectingAllReferences() { collecting_all_references_ = true; }
 
   void FillReferences(V8HeapExplorer* explorer) {
@@ skipping 12 matching lines @@
         explorer->TagBuiltinCodeObject(
             Code::cast(all_references_[all_index]),
             builtins->name(builtin_index++));
       }
       ++all_index;
       if (is_strong) ++strong_index;
       if (reference_tags_[tags_index].index == all_index) ++tags_index;
     }
   }
 
-  void Synchronize(VisitorSynchronization::SyncTag tag) {
+  void Synchronize(VisitorSynchronization::SyncTag tag) override {
     if (collecting_all_references_ &&
         previous_reference_count_ != all_references_.length()) {
       previous_reference_count_ = all_references_.length();
       reference_tags_.Add(IndexTag(previous_reference_count_, tag));
     }
   }
 
  private:
   bool collecting_all_references_;
   List<Object*> strong_references_;
@@ skipping 365 matching lines @@
 
 void V8HeapExplorer::MarkAsWeakContainer(Object* object) {
   if (IsEssentialObject(object) && object->IsFixedArray()) {
     weak_containers_.Insert(object);
   }
 }
 
 
 class GlobalObjectsEnumerator : public ObjectVisitor {
  public:
-  virtual void VisitPointers(Object** start, Object** end) {
+  void VisitPointers(Object** start, Object** end) override {
     for (Object** p = start; p < end; p++) {
       if ((*p)->IsNativeContext()) {
         Context* context = Context::cast(*p);
         JSObject* proxy = context->global_proxy();
         if (proxy->IsJSGlobalProxy()) {
           Object* global = proxy->map()->prototype();
           if (global->IsJSGlobalObject()) {
             objects_.Add(Handle<JSGlobalObject>(JSGlobalObject::cast(global)));
           }
         }
@@ skipping 32 matching lines @@
   }
 
   DeleteArray(urls);
 }
 
 
 class GlobalHandlesExtractor : public ObjectVisitor {
  public:
   explicit GlobalHandlesExtractor(NativeObjectsExplorer* explorer)
       : explorer_(explorer) {}
-  virtual ~GlobalHandlesExtractor() {}
-  virtual void VisitPointers(Object** start, Object** end) {
-    UNREACHABLE();
-  }
-  virtual void VisitEmbedderReference(Object** p, uint16_t class_id) {
+  ~GlobalHandlesExtractor() override {}
+  void VisitPointers(Object** start, Object** end) override { UNREACHABLE(); }
+  void VisitEmbedderReference(Object** p, uint16_t class_id) override {
     explorer_->VisitSubtreeWrapper(p, class_id);
   }
  private:
   NativeObjectsExplorer* explorer_;
 };
 
 
 class BasicHeapEntriesAllocator : public HeapEntriesAllocator {
  public:
   BasicHeapEntriesAllocator(
@@ skipping 910 matching lines @@
   for (int i = 1; i < sorted_strings.length(); ++i) {
     writer_->AddCharacter(',');
     SerializeString(sorted_strings[i]);
     if (writer_->aborted()) return;
   }
 }
 
 
 }  // namespace internal
 }  // namespace v8