services/resource_coordinator/public/cpp/memory_instrumentation/memory_instrumentation_mojom_traits.cc

// Copyright 2017 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 "services/resource_coordinator/public/cpp/memory_instrumentation/memory_instrumentation_mojom_traits.h"

namespace mojo {

// static
memory_instrumentation::mojom::DumpType
EnumTraits<memory_instrumentation::mojom::DumpType,
           base::trace_event::MemoryDumpType>::
    ToMojom(base::trace_event::MemoryDumpType type) {
  switch (type) {
    case base::trace_event::MemoryDumpType::PERIODIC_INTERVAL:
      return memory_instrumentation::mojom::DumpType::PERIODIC_INTERVAL;
    case base::trace_event::MemoryDumpType::EXPLICITLY_TRIGGERED:
      return memory_instrumentation::mojom::DumpType::EXPLICITLY_TRIGGERED;
    case base::trace_event::MemoryDumpType::SUMMARY_ONLY:
      return memory_instrumentation::mojom::DumpType::SUMMARY_ONLY;
    default:
      CHECK(false) << "Invalid type: " << static_cast<uint8_t>(type);
      // This should not be reached. Just return a random value.
      return memory_instrumentation::mojom::DumpType::PERIODIC_INTERVAL;
  }
}

// static
bool EnumTraits<memory_instrumentation::mojom::DumpType,
                base::trace_event::MemoryDumpType>::
    FromMojom(memory_instrumentation::mojom::DumpType input,
              base::trace_event::MemoryDumpType* out) {
  switch (input) {
    case memory_instrumentation::mojom::DumpType::PERIODIC_INTERVAL:
      *out = base::trace_event::MemoryDumpType::PERIODIC_INTERVAL;
      break;
    case memory_instrumentation::mojom::DumpType::EXPLICITLY_TRIGGERED:
      *out = base::trace_event::MemoryDumpType::EXPLICITLY_TRIGGERED;
      break;
    case memory_instrumentation::mojom::DumpType::SUMMARY_ONLY:
      *out = base::trace_event::MemoryDumpType::SUMMARY_ONLY;
      break;
    default:
      NOTREACHED() << "Invalid type: " << static_cast<uint8_t>(input);
      return false;
  }
  return true;
}

// static
memory_instrumentation::mojom::LevelOfDetail
EnumTraits<memory_instrumentation::mojom::LevelOfDetail,
           base::trace_event::MemoryDumpLevelOfDetail>::
    ToMojom(base::trace_event::MemoryDumpLevelOfDetail level_of_detail) {
  switch (level_of_detail) {
    case base::trace_event::MemoryDumpLevelOfDetail::BACKGROUND:
      return memory_instrumentation::mojom::LevelOfDetail::BACKGROUND;
    case base::trace_event::MemoryDumpLevelOfDetail::LIGHT:
      return memory_instrumentation::mojom::LevelOfDetail::LIGHT;
    case base::trace_event::MemoryDumpLevelOfDetail::DETAILED:
      return memory_instrumentation::mojom::LevelOfDetail::DETAILED;
    default:
      CHECK(false) << "Invalid type: " << static_cast<uint8_t>(level_of_detail);
      // This should not be reached. Just return a random value.
      return memory_instrumentation::mojom::LevelOfDetail::BACKGROUND;
  }
}

// static
bool EnumTraits<memory_instrumentation::mojom::LevelOfDetail,
                base::trace_event::MemoryDumpLevelOfDetail>::
    FromMojom(memory_instrumentation::mojom::LevelOfDetail input,
              base::trace_event::MemoryDumpLevelOfDetail* out) {
  switch (input) {
    case memory_instrumentation::mojom::LevelOfDetail::BACKGROUND:
      *out = base::trace_event::MemoryDumpLevelOfDetail::BACKGROUND;
      break;
    case memory_instrumentation::mojom::LevelOfDetail::LIGHT:
      *out = base::trace_event::MemoryDumpLevelOfDetail::LIGHT;
      break;
    case memory_instrumentation::mojom::LevelOfDetail::DETAILED:
      *out = base::trace_event::MemoryDumpLevelOfDetail::DETAILED;
      break;
    default:
      NOTREACHED() << "Invalid type: " << static_cast<uint8_t>(input);
      return false;
  }
  return true;
}

// static
bool StructTraits<memory_instrumentation::mojom::RequestArgsDataView,
                  base::trace_event::MemoryDumpRequestArgs>::
    Read(memory_instrumentation::mojom::RequestArgsDataView input,
         base::trace_event::MemoryDumpRequestArgs* out) {
  out->dump_guid = input.dump_guid();
  if (!input.ReadDumpType(&out->dump_type))
    return false;
  if (!input.ReadLevelOfDetail(&out->level_of_detail))
    return false;
  return true;
}

// static
bool StructTraits<
    memory_instrumentation::mojom::RawAllocatorDumpEdgeDataView,
    base::trace_event::ProcessMemoryDump::MemoryAllocatorDumpEdge>::
    Read(memory_instrumentation::mojom::RawAllocatorDumpEdgeDataView input,
         base::trace_event::ProcessMemoryDump::MemoryAllocatorDumpEdge* out) {
  out->source = base::trace_event::MemoryAllocatorDumpGuid(input.source_id());
  out->target = base::trace_event::MemoryAllocatorDumpGuid(input.target_id());
  out->importance = input.importance();
  out->overridable = input.overridable();
  return true;
}

// static
bool UnionTraits<
    memory_instrumentation::mojom::RawAllocatorDumpEntryValueDataView,
    base::trace_event::MemoryAllocatorDump::Entry>::
    Read(
        memory_instrumentation::mojom::RawAllocatorDumpEntryValueDataView input,
        base::trace_event::MemoryAllocatorDump::Entry* out) {
  using memory_instrumentation::mojom::RawAllocatorDumpEntryValue;
  switch (input.tag()) {
    case RawAllocatorDumpEntryValue::Tag::VALUE_STRING: {
      std::string value_string;
      if (!input.ReadValueString(&value_string))
        return false;
      out->value_string = std::move(value_string);
      out->entry_type = base::trace_event::MemoryAllocatorDump::Entry::kString;
      break;
    }
    case RawAllocatorDumpEntryValue::Tag::VALUE_UINT64: {
      out->value_uint64 = input.value_uint64();
      out->entry_type = base::trace_event::MemoryAllocatorDump::Entry::kUint64;
      break;
    }
    default:
      return false;
  }
  return true;
}

// static
bool StructTraits<memory_instrumentation::mojom::RawAllocatorDumpEntryDataView,
                  base::trace_event::MemoryAllocatorDump::Entry>::
    Read(memory_instrumentation::mojom::RawAllocatorDumpEntryDataView input,
         base::trace_event::MemoryAllocatorDump::Entry* out) {
  if (!input.ReadName(&out->name) || !input.ReadUnits(&out->units))
    return false;
  if (!input.ReadValue(out))
    return false;
  return true;
}

// static
bool StructTraits<memory_instrumentation::mojom::RawAllocatorDumpDataView,
                  std::unique_ptr<base::trace_event::MemoryAllocatorDump>>::
    Read(memory_instrumentation::mojom::RawAllocatorDumpDataView input,
         std::unique_ptr<base::trace_event::MemoryAllocatorDump>* out) {
  std::string absolute_name;
  if (!input.ReadAbsoluteName(&absolute_name))
    return false;
  base::trace_event::MemoryDumpLevelOfDetail level_of_detail;
  if (!input.ReadLevelOfDetail(&level_of_detail))
    return false;
  auto mad = std::make_unique<base::trace_event::MemoryAllocatorDump>(
      absolute_name, level_of_detail,
      base::trace_event::MemoryAllocatorDumpGuid(input.id()));
  if (input.weak())
    mad->set_flags(base::trace_event::MemoryAllocatorDump::WEAK);
  if (!input.ReadEntries(mad->mutable_entries_for_serialization()))
    return false;
  *out = std::move(mad);
  return true;
}

// static
bool StructTraits<memory_instrumentation::mojom::RawProcessMemoryDumpDataView,
                  std::unique_ptr<base::trace_event::ProcessMemoryDump>>::
    Read(memory_instrumentation::mojom::RawProcessMemoryDumpDataView input,
         std::unique_ptr<base::trace_event::ProcessMemoryDump>* out) {
  base::trace_event::MemoryDumpArgs dump_args;
  if (!input.ReadLevelOfDetail(&dump_args.level_of_detail))
    return false;
  std::vector<base::trace_event::ProcessMemoryDump::MemoryAllocatorDumpEdge>
      edges;
  if (!input.ReadAllocatorDumpEdges(&edges))
    return false;
  std::vector<std::unique_ptr<base::trace_event::MemoryAllocatorDump>> dumps;
  if (!input.ReadAllocatorDumps(&dumps))
    return false;
  auto pmd = std::make_unique<base::trace_event::ProcessMemoryDump>(dump_args);
  pmd->SetAllocatorDumpsForSerialization(std::move(dumps));
  pmd->SetAllEdgesForSerialization(edges);
  *out = std::move(pmd);
  return true;
}

}  // namespace mojo