Collect field trial information from the stability file

components/browser_watcher/postmortem_report_collector.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_collector.h"
 
 #include <utility>
 
 #include "base/debug/activity_analyzer.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/path_service.h"
 #include "base/strings/string_piece.h"
+#include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/browser_watcher/postmortem_minidump_writer.h"
+#include "components/variations/active_field_trials.h"
 #include "third_party/crashpad/crashpad/client/settings.h"
 #include "third_party/crashpad/crashpad/util/misc/uuid.h"
 
 using base::FilePath;
 
 namespace browser_watcher {
 
 using ActivitySnapshot = base::debug::ThreadActivityAnalyzer::Snapshot;
 using base::debug::ActivityUserData;
 using base::debug::GlobalActivityAnalyzer;
 using base::debug::GlobalActivityTracker;
 using base::debug::ThreadActivityAnalyzer;
 using crashpad::CrashReportDatabase;
 
 namespace {
 
+const char kFieldTrialKeyPrefix[] = "FieldTrial.";
+
 // Collects stability user data from the recorded format to the collected
 // format.
 void CollectUserData(
     const ActivityUserData::Snapshot& recorded_map,
-    google::protobuf::Map<std::string, TypedValue>* collected_map) {
+    google::protobuf::Map<std::string, TypedValue>* collected_map,
+    StabilityReport* report) {
   DCHECK(collected_map);
 
   for (const auto& name_and_value : recorded_map) {
+    const std::string& key = name_and_value.first;
     const ActivityUserData::TypedValue& recorded_value = name_and_value.second;
     TypedValue collected_value;
 
     switch (recorded_value.type()) {
       case ActivityUserData::END_OF_VALUES:
         NOTREACHED();
         break;
       case ActivityUserData::RAW_VALUE:
         collected_value.set_bytes_value(recorded_value.Get().as_string());
         break;
       case ActivityUserData::RAW_VALUE_REFERENCE: {
         base::StringPiece recorded_ref = recorded_value.GetReference();
         TypedValue::Reference* collected_ref =
             collected_value.mutable_bytes_reference();
         collected_ref->set_address(
             reinterpret_cast<uintptr_t>(recorded_ref.data()));
         collected_ref->set_size(recorded_ref.size());
         break;
       }
-      case ActivityUserData::STRING_VALUE:
-        collected_value.set_string_value(
-            recorded_value.GetString().as_string());
+      case ActivityUserData::STRING_VALUE: {
+        std::string value = recorded_value.GetString().as_string();
+
+        if (report && base::StartsWith(key, kFieldTrialKeyPrefix,

[bcwhite, 2017/02/14 15:42:14]

To be clear, you want field-trial strings to go into the collected values if no
report is requested?

[manzagop (departed), 2017/02/14 19:21:15]

Yeah, this is clunky. I'm using this function to collect both the global data,
which may contain finch data, and activity data, which should not. In the first
case I pass in the report, in the second I don't have one.

[bcwhite, 2017/02/14 21:05:16]

On the second pass, do you want the field trials to be ignored or included with
other global data?

[manzagop (departed), 2017/02/14 21:27:57]

Not sure I follow: what's the second pass? Do you mean for activity-local data?
Those shouldn't have field trial data. If they do, it's fine to leave it in,
that way we'll know we're doing something wrong.

[bcwhite, 2017/02/15 16:24:19]

You said that "in the second I don't have one" so I just wanted to be sure that,
during that case, you want all the field trials added as their existing strings
into the collected_map.

[manzagop (departed), 2017/02/15 18:35:07]

Acknowledged.

+                                       base::CompareCase::SENSITIVE)) {
+          // This entry represents an active Finch experiment.
+          std::string trial_name =
+              key.substr(std::strlen(kFieldTrialKeyPrefix));
+          variations::ActiveGroupId group_id =
+              variations::MakeActiveGroupId(trial_name, value);
+          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);

[bcwhite, 2017/02/14 15:42:14]

I believe set_string_value will accept (char*, len) which would be more
efficient that creating a std::string from the returned StringPiece.

That's probably also true for set_bytes_value and set_char_value.

[manzagop (departed), 2017/02/14 19:21:15]

Nice! Ah, but MakeActiveGroupId wants a string. Still changed it, if that
function ever changes. Also changed the other cases.

         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:
         collected_value.set_char_value(
             std::string(1, recorded_value.GetChar()));
         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());
         break;
       case ActivityUserData::UNSIGNED_VALUE:
         collected_value.set_unsigned_value(recorded_value.GetUint());
         break;
     }
 
-    (*collected_map)[name_and_value.first].Swap(&collected_value);
+    (*collected_map)[key].Swap(&collected_value);
   }
 }
 
 void CollectModuleInformation(
     const std::vector<GlobalActivityTracker::ModuleInfo>& modules,
     ProcessState* process_state) {
   DCHECK(process_state);
 
   char code_identifier[17];
   char debug_identifier[41];
@@ skipping 178 matching lines @@
 
   // Create the report, then flesh it out.
   report->reset(new StabilityReport());
 
   // Collect log messages.
   for (const std::string& message : log_messages) {
     (*report)->add_log_messages(message);
   }
 
   // Collect global user data.
-  CollectUserData(global_data_snapshot, (*report)->mutable_global_data());
+  CollectUserData(global_data_snapshot, (*report)->mutable_global_data(),
+                  report->get());
 
   // Collect thread activity data.
   // Note: a single process is instrumented.
   ProcessState* process_state = (*report)->add_process_states();
   for (; thread_analyzer != nullptr;
        thread_analyzer = global_analyzer->GetNextAnalyzer()) {
     // Only valid analyzers are expected per contract of GetFirstAnalyzer /
     // GetNextAnalyzer.
     DCHECK(thread_analyzer->IsValid());
 
@@ skipping 50 matching lines @@
         collected->set_type(Activity::ACT_PROCESS_WAIT);
         collected->set_process_id(recorded.data.process.process_id);
         break;
       default:
         break;
     }
 
     // Collect user data
     if (i < snapshot.user_data_stack.size()) {
       CollectUserData(snapshot.user_data_stack[i],
-                      collected->mutable_user_data());
+                      collected->mutable_user_data(), nullptr);
     }
   }
 }
 
 bool PostmortemReportCollector::WriteReportToMinidump(
     const StabilityReport& report,
     const crashpad::UUID& client_id,
     const crashpad::UUID& report_id,
     base::PlatformFile minidump_file) {
   MinidumpInfo minidump_info;
   minidump_info.client_id = client_id;
   minidump_info.report_id = report_id;
   // TODO(manzagop): replace this information, i.e. the reporter's attributes,
   // by that of the reportee. Doing so requires adding this information to the
   // stability report. In the meantime, there is a tolerable information
   // mismatch after upgrades.
   minidump_info.product_name = product_name();
   minidump_info.version_number = version_number();
   minidump_info.channel_name = channel_name();
 #if defined(ARCH_CPU_X86)
   minidump_info.platform = std::string("Win32");
 #elif defined(ARCH_CPU_X86_64)
   minidump_info.platform = std::string("Win64");
 #endif
 
   return WritePostmortemDump(minidump_file, report, minidump_info);
 }
 
 }  // namespace browser_watcher