VM: Free [TimelineEventBlock]s before shutting down

runtime/vm/timeline.h

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef RUNTIME_VM_TIMELINE_H_
 #define RUNTIME_VM_TIMELINE_H_
 
 #include "include/dart_tools_api.h"
 
 #include "vm/allocation.h"
@@ skipping 663 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(TimelineEventRecorder);
 };
 
 
 // An abstract recorder that stores events in a buffer of fixed capacity.
 class TimelineEventFixedBufferRecorder : public TimelineEventRecorder {
  public:
   static const intptr_t kDefaultCapacity = 8192;
 
   explicit TimelineEventFixedBufferRecorder(intptr_t capacity);
-  ~TimelineEventFixedBufferRecorder();
+  virtual ~TimelineEventFixedBufferRecorder();
 
   void PrintJSON(JSONStream* js, TimelineEventFilter* filter);
   void PrintTraceEvent(JSONStream* js, TimelineEventFilter* filter);
 
  protected:
   TimelineEvent* StartEvent();
   void CompleteEvent(TimelineEvent* event);
   TimelineEventBlock* GetHeadBlockLocked();
   intptr_t FindOldestBlockIndex() const;
   void Clear();
 
   void PrintJSONEvents(JSONArray* array, TimelineEventFilter* filter);
 
   TimelineEventBlock** blocks_;
   intptr_t capacity_;
   intptr_t num_blocks_;
   intptr_t block_cursor_;
 };
 
 
 // A recorder that stores events in a buffer of fixed capacity. When the buffer
 // is full, new events overwrite old events.
 class TimelineEventRingRecorder : public TimelineEventFixedBufferRecorder {
  public:
   explicit TimelineEventRingRecorder(intptr_t capacity = kDefaultCapacity)
       : TimelineEventFixedBufferRecorder(capacity) {}
-  ~TimelineEventRingRecorder() {}
+  virtual ~TimelineEventRingRecorder() {}
 
   const char* name() const { return "Ring"; }
 
  protected:
   TimelineEventBlock* GetNewBlockLocked();
 };
 
 
 // A recorder that writes events to Android Systrace. Events are also stored in
 // a buffer of fixed capacity. When the buffer is full, new events overwrite
 // old events.
 class TimelineEventSystraceRecorder : public TimelineEventFixedBufferRecorder {
  public:
   explicit TimelineEventSystraceRecorder(intptr_t capacity = kDefaultCapacity);
-
-  ~TimelineEventSystraceRecorder();
+  virtual ~TimelineEventSystraceRecorder();
 
   const char* name() const { return "Systrace"; }
 
  protected:
   TimelineEventBlock* GetNewBlockLocked();
   void CompleteEvent(TimelineEvent* event);
 
   int systrace_fd_;
 };
 
 
 // A recorder that stores events in a buffer of fixed capacity. When the buffer
 // is full, new events are dropped.
 class TimelineEventStartupRecorder : public TimelineEventFixedBufferRecorder {
  public:
   explicit TimelineEventStartupRecorder(intptr_t capacity = kDefaultCapacity)
       : TimelineEventFixedBufferRecorder(capacity) {}
-  ~TimelineEventStartupRecorder() {}
+  virtual ~TimelineEventStartupRecorder() {}
 
   const char* name() const { return "Startup"; }
 
  protected:
   TimelineEventBlock* GetNewBlockLocked();
 };
 
 
 // An abstract recorder that calls |OnEvent| whenever an event is complete.
 // This should only be used for testing.
 class TimelineEventCallbackRecorder : public TimelineEventRecorder {
  public:
   TimelineEventCallbackRecorder();
-  ~TimelineEventCallbackRecorder();
+  virtual ~TimelineEventCallbackRecorder();
 
   void PrintJSON(JSONStream* js, TimelineEventFilter* filter);
   void PrintTraceEvent(JSONStream* js, TimelineEventFilter* filter);
 
   // Called when |event| is completed. It is unsafe to keep a reference to
   // |event| as it may be freed as soon as this function returns.
   virtual void OnEvent(TimelineEvent* event) = 0;
 
   const char* name() const { return "Callback"; }
 
  protected:
   TimelineEventBlock* GetNewBlockLocked() { return NULL; }
   TimelineEventBlock* GetHeadBlockLocked() { return NULL; }
   void Clear() {}
   TimelineEvent* StartEvent();
   void CompleteEvent(TimelineEvent* event);
 };
 
 
 // A recorder that stores events in chains of blocks of events.
 // NOTE: This recorder will continue to allocate blocks until it exhausts
 // memory.
 class TimelineEventEndlessRecorder : public TimelineEventRecorder {
  public:
   TimelineEventEndlessRecorder();
+  virtual ~TimelineEventEndlessRecorder();
 
   void PrintJSON(JSONStream* js, TimelineEventFilter* filter);
   void PrintTraceEvent(JSONStream* js, TimelineEventFilter* filter);
 
   const char* name() const { return "Endless"; }
 
  protected:
   TimelineEvent* StartEvent();
   void CompleteEvent(TimelineEvent* event);
   TimelineEventBlock* GetNewBlockLocked();
@@ skipping 25 matching lines @@
 
  private:
   TimelineEventBlock* current_;
   TimelineEventRecorder* recorder_;
 };
 
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_TIMELINE_H_