Make `benchmark.mojo` resilient to incorrect trace events.

apps/benchmark/event.cc

 // Copyright 2015 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 "apps/benchmark/event.h"
 
 #include <map>
 #include <stack>
 
 #include "base/json/json_reader.h"
@@ skipping 82 matching lines @@
     }
   }
   return true;
 }
 
 bool ParseEvents(base::ListValue* event_list, std::vector<Event>* result) {
   result->clear();
 
   for (base::Value* val : *event_list) {
     base::DictionaryValue* event_dict;
-    if (!val->GetAsDictionary(&event_dict))
-      return false;
+    if (!val->GetAsDictionary(&event_dict)) {
+      LOG(WARNING) << "Ignoring incorrect trace event (not a dictionary)";
+      continue;
+    }
 
     Event event;
 
     std::string phase;
     if (!event_dict->GetString("ph", &phase)) {
-      LOG(ERROR) << "Incorrect trace event (missing phase)";
-      return false;
+      LOG(WARNING) << "Ignoring incorrect trace event (missing phase)";
+      continue;
     }
     if (phase == "X") {
       event.type = EventType::COMPLETE;
     } else if (phase == "I") {
       event.type = EventType::INSTANT;
     } else {
       // Skip all event types we do not handle.
       continue;
     }
 
     if (!event_dict->GetString("name", &event.name)) {
       LOG(ERROR) << "Incorrect trace event (no name)";
       return false;
     }
 
     if (!event_dict->GetString("cat", &event.categories)) {
-      LOG(ERROR) << "Incorrect trace event (no categories)";
-      return false;
+      LOG(WARNING) << "Ignoring incorrect trace event (no categories)";
+      continue;
     }
 
     double timestamp;
     if (!event_dict->GetDouble("ts", &timestamp)) {
-      LOG(ERROR) << "Incorrect trace event (no timestamp)";
-      return false;
+      LOG(WARNING) << "Ingoring incorrect trace event (no timestamp)";
+      continue;
     }
     event.timestamp = base::TimeTicks::FromInternalValue(timestamp);
 
     if (event.type == EventType::COMPLETE) {
       double duration;
       if (!event_dict->GetDouble("dur", &duration)) {
-        LOG(ERROR) << "Incorrect complete or duration event (no duration)";
-        return false;
+        LOG(WARNING) << "Ignoring incorrect complete event (no duration)";
+        continue;
       }
 
       event.duration = base::TimeDelta::FromInternalValue(duration);
     } else {
       event.duration = base::TimeDelta();
     }
 
     result->push_back(event);
   }
   return true;
@@ skipping 18 matching lines @@
   }
 
   if (!JoinDurationEvents(event_list))
     return false;
 
   if (!ParseEvents(event_list, result))
     return false;
   return true;
 }
 }  // namespace benchmark