base/metrics/histogram_shared_memory_unittest.cc

// Copyright 2023 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "base/metrics/histogram_shared_memory.h"

#include "base/base_switches.h"
#include "base/command_line.h"
#include "base/metrics/persistent_histogram_allocator.h"
#include "base/process/launch.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_split.h"
#include "base/test/multiprocess_test.h"
#include "base/test/scoped_feature_list.h"
#include "base/test/test_timeouts.h"
#include "base/unguessable_token.h"
#include "build/build_config.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "testing/multiprocess_func_list.h"

#if BUILDFLAG(IS_POSIX) || BUILDFLAG(IS_FUCHSIA)
#include "base/files/platform_file.h"
#include "base/posix/global_descriptors.h"
#endif

namespace base {
namespace {

constexpr size_t kArbitrarySize = 64 << 10;

#if BUILDFLAG(IS_POSIX) && !BUILDFLAG(IS_APPLE)
constexpr GlobalDescriptors::Key kArbitraryDescriptorKey = 42;
#endif

}  // namespace

TEST(HistogramSharedMemoryTest, Create) {
  UnsafeSharedMemoryRegion region;

  constexpr int kProcessId = 1234;
  constexpr int kProcessType = 5678;
  constexpr char kProcessName[] = "TestProcess";

  auto shared_memory = HistogramSharedMemory::Create(
      kProcessId, {kProcessType, kProcessName, kArbitrarySize});

  ASSERT_TRUE(shared_memory.has_value());

  ASSERT_TRUE(shared_memory->region.IsValid());
  EXPECT_EQ(kArbitrarySize, shared_memory->region.GetSize());

  ASSERT_TRUE(shared_memory->allocator);
  EXPECT_EQ(kArbitrarySize, shared_memory->allocator->size());
}

namespace {
// Constants from content::ProcessType;
constexpr int PROCESS_TYPE_RENDERER = 3;
constexpr int PROCESS_TYPE_GPU = 9;
constexpr int PROCESS_TYPE_UTILITY = 6;
}  // namespace

TEST(HistogramSharedMemoryTest, PassOnCommandLineIsDisabled) {
  test::ScopedFeatureList feature_list;
  feature_list.InitAndDisableFeature(kPassHistogramSharedMemoryOnLaunch);

  EXPECT_FALSE(
      HistogramSharedMemory::PassOnCommandLineIsEnabled(PROCESS_TYPE_RENDERER));
  EXPECT_FALSE(
      HistogramSharedMemory::PassOnCommandLineIsEnabled(PROCESS_TYPE_GPU));
  EXPECT_FALSE(
      HistogramSharedMemory::PassOnCommandLineIsEnabled(PROCESS_TYPE_UTILITY));
}

TEST(HistogramSharedMemoryTest, PassOnCommandLineIsEnabled) {
  test::ScopedFeatureList feature_list;
  feature_list.InitAndEnableFeature(kPassHistogramSharedMemoryOnLaunch);

  EXPECT_TRUE(
      HistogramSharedMemory::PassOnCommandLineIsEnabled(PROCESS_TYPE_RENDERER));
#if BUILDFLAG(IS_CHROMEOS)
  EXPECT_FALSE(
      HistogramSharedMemory::PassOnCommandLineIsEnabled(PROCESS_TYPE_GPU));
#else   // !BUILDFLAG(IS_CHROMEOS)
  EXPECT_TRUE(
      HistogramSharedMemory::PassOnCommandLineIsEnabled(PROCESS_TYPE_GPU));
#endif  // !BUILDFLAG(IS_CHROMEOS)

#if BUILDFLAG(IS_ANDROID)
  EXPECT_FALSE(
      HistogramSharedMemory::PassOnCommandLineIsEnabled(PROCESS_TYPE_UTILITY));
#else   // !BUILDFLAG(IS_ANDROID)
  EXPECT_TRUE(
      HistogramSharedMemory::PassOnCommandLineIsEnabled(PROCESS_TYPE_UTILITY));
#endif  // !BUILDFLAG(IS_ANDROID)
}

MULTIPROCESS_TEST_MAIN(InitFromLaunchParameters) {
// On POSIX we generally use the descriptor map to look up inherited handles.
// On most POSIX platforms we have to manually sure the mapping is updated,
// for the purposes of this test.
//