Handle duration events when filtering the timeline for a time range

runtime/vm/timeline.cc

 // 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.
 
 #include <cstdlib>
 
 #include "vm/atomic.h"
 #include "vm/isolate.h"
 #include "vm/json_stream.h"
 #include "vm/lockers.h"
@@ skipping 364 matching lines @@
   if (isolate != NULL) {
     isolate_id_ = isolate->main_port();
   } else {
     isolate_id_ = ILLEGAL_PORT;
   }
   label_ = label;
   FreeArguments();
 }
 
 
+bool TimelineEvent::Within(int64_t time_origin_micros,
+                           int64_t time_extent_micros) {
+  if ((time_origin_micros == -1) ||
+      (time_extent_micros == -1)) {
+    // No time range specified.
+    return true;
+  }
+  if (IsFinishedDuration()) {
+    // Event is from e_t0 to e_t1.
+    int64_t e_t0 = TimeOrigin();
+    int64_t e_t1 = TimeEnd();
+    ASSERT(e_t0 <= e_t1);
+    // Range is from r_t0 to r_t1.
+    int64_t r_t0 = time_origin_micros;
+    int64_t r_t1 = time_origin_micros + time_extent_micros;
+    ASSERT(r_t0 <= r_t1);
+    return !((r_t1 < e_t0) || (e_t1 < r_t0));
+  }
+  int64_t delta = TimeOrigin() - time_origin_micros;
+  return (delta >= 0) && (delta <= time_extent_micros);
+}
+
+
 const char* TimelineEvent::GetSerializedJSON() const {
   ASSERT(event_type() == kSerializedJSON);
   ASSERT(arguments_length_ == 1);
   ASSERT(arguments_ != NULL);
   return arguments_[0].value;
 }
 
 
 void TimelineEvent::PrintJSON(JSONStream* stream) const {
   if (event_type() == kSerializedJSON) {
@@ skipping 329 matching lines @@
       time_extent_micros_(time_extent_micros) {
   ASSERT(time_origin_micros_ >= -1);
   ASSERT(time_extent_micros_ >= -1);
 }
 
 
 TimelineEventFilter::~TimelineEventFilter() {
 }
 
 
-bool TimelineEventFilter::EventInTimeRange(TimelineEvent* event) {
-  if (event == NULL) {
-    return false;
-  }
-  if ((time_origin_micros_ == -1) ||
-      (time_extent_micros_ == -1)) {
-    // No time filter applied.
-    return true;
-  }
-  // TODO(johnmccutchan): Some events span a range of time, check the range and
-  // not just the start time.
-  int64_t delta = event->TimeOrigin() - time_origin_micros_;
-  return (delta >= 0) && (delta <= time_extent_micros_);
-}
-
-
 IsolateTimelineEventFilter::IsolateTimelineEventFilter(
     Dart_Port isolate_id,
     int64_t time_origin_micros,
     int64_t time_extent_micros)
     : TimelineEventFilter(time_origin_micros,
                           time_extent_micros),
       isolate_id_(isolate_id) {
 }
 
 
@@ skipping 200 matching lines @@
     return;
   }
   for (intptr_t block_idx = 0; block_idx < num_blocks_; block_idx++) {
     TimelineEventBlock* block =
         blocks_[(block_idx + block_offset) % num_blocks_];
     if (!filter->IncludeBlock(block)) {
       continue;
     }
     for (intptr_t event_idx = 0; event_idx < block->length(); event_idx++) {
       TimelineEvent* event = block->At(event_idx);
-      if (filter->IncludeEvent(event) && filter->EventInTimeRange(event)) {
+      if (filter->IncludeEvent(event) &&
+          event->Within(filter->time_origin_micros(),
+                        filter->time_extent_micros())) {
         events->AddValue(event);
       }
     }
   }
 }
 
 
 void TimelineEventRingRecorder::PrintJSON(JSONStream* js,
                                           TimelineEventFilter* filter) {
   JSONObject topLevel(js);
@@ skipping 171 matching lines @@
   MutexLocker ml(&lock_);
   TimelineEventBlock* current = head_;
   while (current != NULL) {
     if (!filter->IncludeBlock(current)) {
       current = current->next();
       continue;
     }
     intptr_t length = current->length();
     for (intptr_t i = 0; i < length; i++) {
       TimelineEvent* event = current->At(i);
-      if (filter->IncludeEvent(event) && filter->EventInTimeRange(event)) {
+      if (filter->IncludeEvent(event) &&
+          event->Within(filter->time_origin_micros(),
+                        filter->time_extent_micros())) {
         events->AddValue(event);
       }
     }
     current = current->next();
   }
 }
 
 
 void TimelineEventEndlessRecorder::Clear() {
   TimelineEventBlock* current = head_;
@@ skipping 132 matching lines @@
 
 
 TimelineEventBlock* TimelineEventBlockIterator::Next() {
   ASSERT(current_ != NULL);
   TimelineEventBlock* r = current_;
   current_ = current_->next();
   return r;
 }
 
 }  // namespace dart