StabilityReport proto changes for multi-process support

components/browser_watcher/stability_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/stability_report_extractor.h"
 
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 61 matching lines @@
               key.substr(std::strlen(kFieldTrialKeyPrefix));
           variations::ActiveGroupId group_id =
               variations::MakeActiveGroupId(trial_name, value.as_string());
           FieldTrial* field_trial = report->add_field_trials();
           field_trial->set_name_id(group_id.name);
           field_trial->set_group_id(group_id.group);
           continue;
         }
 
         collected_value.set_string_value(value.data(), value.size());
+
+        // Promote version information to the global key value store.
+        if (report) {
+          bool should_promote =
+              key == kStabilityProduct || key == kStabilityChannel ||
+              key == kStabilityPlatform || key == kStabilityVersion;
+          if (should_promote) {
+            (*report->mutable_global_data())[key].Swap(&collected_value);
+            continue;
+          }
+        }
+
         break;
       }
       case ActivityUserData::STRING_VALUE_REFERENCE: {
         base::StringPiece recorded_ref = recorded_value.GetStringReference();
         TypedValue::Reference* collected_ref =
             collected_value.mutable_string_reference();
         collected_ref->set_address(
             reinterpret_cast<uintptr_t>(recorded_ref.data()));
         collected_ref->set_size(recorded_ref.size());
         break;
       }
       case ActivityUserData::CHAR_VALUE: {
         char char_value = recorded_value.GetChar();
         collected_value.set_char_value(&char_value, 1);
         break;
       }
       case ActivityUserData::BOOL_VALUE:
         collected_value.set_bool_value(recorded_value.GetBool());
         break;
       case ActivityUserData::SIGNED_VALUE:
         collected_value.set_signed_value(recorded_value.GetInt());
+
+        // Promote the execution timestamp to the global key value store.
+        if (report && key == kStabilityStartTimestamp) {
+          (*report->mutable_global_data())[key].Swap(&collected_value);
+          continue;
+        }
+
         break;
       case ActivityUserData::UNSIGNED_VALUE:
         collected_value.set_unsigned_value(recorded_value.GetUint());
         break;
     }
 
     (*collected_map)[key].Swap(&collected_value);
   }
 }
 
@@ skipping 96 matching lines @@
     Activity* collected = thread_state->add_activities();
 
     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
+bool SetProcessType(ProcessState* process_state) {
+  DCHECK(process_state);
+  google::protobuf::Map<std::string, TypedValue>* process_data =
+      process_state->mutable_data();
 
-CollectionStatus Extract(const base::FilePath& stability_file,
-                         StabilityReport* report) {
+  const auto it = process_data->find(kStabilityProcessType);
+  if (it == process_data->end())
+    return false;
+
+  const TypedValue& value = it->second;
+  if (value.value_case() != TypedValue::kSignedValue)
+    return false;
+
+  process_state->set_process_type(
+      static_cast<browser_watcher::ProcessState_Type>(value.signed_value()));
+  process_data->erase(it);
+  return true;
+}
+
+void CollectProcess(int64_t pid,
+                    GlobalActivityAnalyzer* analyzer,
+                    StabilityReport* report) {
+  DCHECK(analyzer);
   DCHECK(report);
 
-  // Create a global analyzer.
-  std::unique_ptr<GlobalActivityAnalyzer> global_analyzer =
-      GlobalActivityAnalyzer::CreateWithFile(stability_file);
-  if (!global_analyzer)
-    return ANALYZER_CREATION_FAILED;
-
-  // Extract data for only the first process.
-  // TODO(manzagop): Extend this to all processes.
-  int64_t pid = global_analyzer->GetFirstProcess();
-
-  // Early exit if there is no data.
-  std::vector<std::string> log_messages = global_analyzer->GetLogMessages();
-  ActivityUserData::Snapshot process_data_snapshot =
-      global_analyzer->GetProcessDataSnapshot(pid);
-
-  ThreadActivityAnalyzer* thread_analyzer =
-      global_analyzer->GetFirstAnalyzer(pid);
-  if (log_messages.empty() && process_data_snapshot.empty() &&
-      !thread_analyzer) {
-    return DEBUG_FILE_NO_DATA;
-  }
-
-  report->set_is_complete(global_analyzer->IsDataComplete());
-
-  // Collect log messages.
-  for (const std::string& message : log_messages) {
-    report->add_log_messages(message);
-  }
-
-  // Collect global user data.
-  google::protobuf::Map<std::string, TypedValue>& global_data =
-      *(report->mutable_global_data());
-  CollectUserData(process_data_snapshot, &global_data, report);
+  ProcessState* process_state = report->add_process_states();
 
   // Collect thread activity data.
-  // Note: a single process is instrumented.
-  ProcessState* process_state = report->add_process_states();
+  ThreadActivityAnalyzer* thread_analyzer = analyzer->GetFirstAnalyzer(pid);
   for (; thread_analyzer != nullptr;
-       thread_analyzer = global_analyzer->GetNextAnalyzer()) {
+       thread_analyzer = analyzer->GetNextAnalyzer()) {
     // Only valid analyzers are expected per contract of GetFirstAnalyzer /
     // GetNextAnalyzer.
     DCHECK(thread_analyzer->IsValid());
 
     if (!process_state->has_process_id()) {
       process_state->set_process_id(
           thread_analyzer->activity_snapshot().process_id);
     }
     DCHECK_EQ(thread_analyzer->activity_snapshot().process_id,
               process_state->process_id());
 
     ThreadState* thread_state = process_state->add_threads();
     CollectThread(thread_analyzer->activity_snapshot(), thread_state);
   }
 
+  // Collect global user data.
+  ActivityUserData::Snapshot process_data_snapshot =
+      analyzer->GetProcessDataSnapshot(pid);
+  CollectUserData(process_data_snapshot, process_state->mutable_data(), report);
+  SetProcessType(process_state);
+
   // Collect module information.
-  CollectModuleInformation(global_analyzer->GetModules(), process_state);
+  CollectModuleInformation(analyzer->GetModules(pid), process_state);
+}
+
+}  // namespace
+
+CollectionStatus Extract(const base::FilePath& stability_file,
+                         StabilityReport* report) {
+  DCHECK(report);
+
+  // Create a global analyzer.
+  std::unique_ptr<GlobalActivityAnalyzer> global_analyzer =
+      GlobalActivityAnalyzer::CreateWithFile(stability_file);
+  if (!global_analyzer)
+    return ANALYZER_CREATION_FAILED;
+  report->set_is_complete(global_analyzer->IsDataComplete());
+
+  // Collect process data.
+  for (int64_t pid = global_analyzer->GetFirstProcess(); pid != 0;
+       pid = global_analyzer->GetNextProcess()) {
+    CollectProcess(pid, global_analyzer.get(), report);
+  }
+
+  // Collect log messages.
+  std::vector<std::string> log_messages = global_analyzer->GetLogMessages();
+  for (const std::string& message : log_messages) {
+    report->add_log_messages(message);
+  }
 
   return SUCCESS;
 }
 
 }  // namespace browser_watcher