// 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>

#include "base/debug/activity_analyzer.h"
#include "base/logging.h"
#include "base/strings/string_piece.h"
#include "base/strings/string_util.h"
#include "base/strings/stringprintf.h"
#include "base/strings/utf_string_conversions.h"
#include "components/browser_watcher/stability_data_names.h"
#include "components/variations/active_field_trials.h"
#include "third_party/crashpad/crashpad/util/misc/uuid.h"

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;

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,
    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: {
        base::StringPiece raw = recorded_value.Get();
        collected_value.set_bytes_value(raw.data(), raw.size());
        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: {
        base::StringPiece value = recorded_value.GetString();

        if (report && base::StartsWith(key, kFieldTrialKeyPrefix,
                                       base::CompareCase::SENSITIVE)) {
          // This entry represents an active Field Trial.
          std::string trial_name =
              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);
  }
}

void CollectModuleInformation(
    const std::vector<GlobalActivityTracker::ModuleInfo>& modules,
    ProcessState* process_state) {
  DCHECK(process_state);

  for (const GlobalActivityTracker::ModuleInfo& recorded : modules) {
    CodeModule* collected = process_state->add_modules();
    collected->set_base_address(recorded.address);
    collected->set_size(recorded.size);
    collected->set_code_file(recorded.file);

    // Compute the code identifier using the required format.
    std::string code_identifier =
        base::StringPrintf("%08X%zx", recorded.timestamp, recorded.size);
    collected->set_code_identifier(code_identifier);
    collected->set_debug_file(recorded.debug_file);

    // Compute the debug identifier using the required format.
    const crashpad::UUID* uuid =
        reinterpret_cast<const crashpad::UUID*>(recorded.identifier);
    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 CollectException(const base::debug::Activity& recorded,
                      Exception* collected) {
  DCHECK(collected);
  collected->set_code(recorded.data.exception.code);
  collected->set_program_counter(recorded.calling_address);
  collected->set_exception_address(recorded.origin_address);
  collected->set_time(recorded.time_internal);
}

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);

  if (snapshot.last_exception.activity_type ==
      base::debug::Activity::ACT_EXCEPTION) {
    CollectException(snapshot.last_exception,
                     thread_state->mutable_exception());
  }

  for (size_t i = 0; i < snapshot.activity_stack.size(); ++i) {
    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);
    }
  }
}

bool SetProcessType(ProcessState* process_state) {
  DCHECK(process_state);
  google::protobuf::Map<std::string, TypedValue>* process_data =
      process_state->mutable_data();

  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);

  ProcessState* process_state = report->add_process_states();

  // Collect thread activity data.
  ThreadActivityAnalyzer* thread_analyzer = analyzer->GetFirstAnalyzer(pid);
  for (; thread_analyzer != nullptr;
       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(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