Stability file: collect generic activities

components/browser_watcher/postmortem_report_extractor.cc

 // Copyright 2016 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 "components/browser_watcher/postmortem_report_extractor.h"
 
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 122 matching lines @@
     std::string debug_identifier = base::StringPrintf(
         "%08X%04X%04X%02X%02X%02X%02X%02X%02X%02X%02X%x", uuid->data_1,
         uuid->data_2, uuid->data_3, uuid->data_4[0], uuid->data_4[1],
         uuid->data_5[0], uuid->data_5[1], uuid->data_5[2], uuid->data_5[3],
         uuid->data_5[4], uuid->data_5[5], recorded.age);
     collected->set_debug_identifier(debug_identifier);
     collected->set_is_unloaded(!recorded.is_loaded);
   }
 }
 
+void CollectActivity(const base::debug::Activity& recorded,
+                     Activity* collected) {
+  DCHECK(collected);
+
+  collected->set_time(recorded.time_internal);
+  collected->set_address(recorded.calling_address);
+  collected->set_origin_address(recorded.origin_address);
+
+  // TODO(manzagop): the current collection deals with specific activity types;
+  // consider modifying it to handle the notion of activity categories.
+  switch (recorded.activity_type) {
+    case base::debug::Activity::ACT_TASK_RUN:
+      collected->set_type(Activity::ACT_TASK_RUN);
+      collected->set_task_sequence_id(recorded.data.task.sequence_id);
+      break;
+    case base::debug::Activity::ACT_LOCK_ACQUIRE:
+      collected->set_type(Activity::ACT_LOCK_ACQUIRE);
+      collected->set_lock_address(recorded.data.lock.lock_address);
+      break;
+    case base::debug::Activity::ACT_EVENT_WAIT:
+      collected->set_type(Activity::ACT_EVENT_WAIT);
+      collected->set_event_address(recorded.data.event.event_address);
+      break;
+    case base::debug::Activity::ACT_THREAD_JOIN:
+      collected->set_type(Activity::ACT_THREAD_JOIN);
+      collected->set_thread_id(recorded.data.thread.thread_id);
+      break;
+    case base::debug::Activity::ACT_PROCESS_WAIT:
+      collected->set_type(Activity::ACT_PROCESS_WAIT);
+      collected->set_process_id(recorded.data.process.process_id);
+      break;
+    case base::debug::Activity::ACT_GENERIC:
+      collected->set_type(Activity::ACT_GENERIC);
+      collected->set_generic_id(recorded.data.generic.id);
+      collected->set_generic_data(recorded.data.generic.info);
+      break;
+    default:
+      break;
+  }
+}
+
 void CollectThread(
     const base::debug::ThreadActivityAnalyzer::Snapshot& snapshot,
     ThreadState* thread_state) {
   DCHECK(thread_state);
 
   thread_state->set_thread_name(snapshot.thread_name);
   thread_state->set_thread_id(snapshot.thread_id);
   thread_state->set_activity_count(snapshot.activity_stack_depth);
 
   for (size_t i = 0; i < snapshot.activity_stack.size(); ++i) {
-    const base::debug::Activity& recorded = snapshot.activity_stack[i];
     Activity* collected = thread_state->add_activities();
 
-    // Collect activity.
-    switch (recorded.activity_type) {
-      case base::debug::Activity::ACT_TASK_RUN:
-        collected->set_type(Activity::ACT_TASK_RUN);
-        collected->set_origin_address(recorded.origin_address);
-        collected->set_task_sequence_id(recorded.data.task.sequence_id);
-        break;
-      case base::debug::Activity::ACT_LOCK_ACQUIRE:
-        collected->set_type(Activity::ACT_LOCK_ACQUIRE);
-        collected->set_lock_address(recorded.data.lock.lock_address);
-        break;
-      case base::debug::Activity::ACT_EVENT_WAIT:
-        collected->set_type(Activity::ACT_EVENT_WAIT);
-        collected->set_event_address(recorded.data.event.event_address);
-        break;
-      case base::debug::Activity::ACT_THREAD_JOIN:
-        collected->set_type(Activity::ACT_THREAD_JOIN);
-        collected->set_thread_id(recorded.data.thread.thread_id);
-        break;
-      case base::debug::Activity::ACT_PROCESS_WAIT:
-        collected->set_type(Activity::ACT_PROCESS_WAIT);
-        collected->set_process_id(recorded.data.process.process_id);
-        break;
-      default:
-        break;
-    }
-
-    // Collect user data.
+    CollectActivity(snapshot.activity_stack[i], collected);
     if (i < snapshot.user_data_stack.size()) {
       CollectUserData(snapshot.user_data_stack[i],
                       collected->mutable_user_data(), nullptr);
     }
   }
 }
 
 }  // namespace
 
 CollectionStatus Extract(const base::FilePath& stability_file,
@@ skipping 46 matching lines @@
     CollectThread(thread_analyzer->activity_snapshot(), thread_state);
   }
 
   // Collect module information.
   CollectModuleInformation(global_analyzer->GetModules(), process_state);
 
   return SUCCESS;
 }
 
 }  // namespace browser_watcher