CHROMIUM_VERSION

@@ -1 +1 @@
-135.0.7049.38
+134.0.6998.39

src/AUTHORS

@@ -351,7 +351,6 @@ Dax Kelson <dkelson@gurulabs.com>
 Dean Leitersdorf <dean.leitersdorf@gmail.com>
 Debadree Chatterjee <debadree333@gmail.com>
 Debashish Samantaray <d.samantaray@samsung.com>
-Debin Zhang <debinzhang3@gmail.com>
 Debug Wang <debugwang@tencent.com>
 Deep Shah <deep.shah@samsung.com>
 Deepak Dilip Borade <deepak.db@samsung.com>
@@ -1030,7 +1029,6 @@ Mohamed Mansour <m0.interactive@gmail.com>
 Mohamed Hany Youns <mohamedhyouns@gmail.com>
 Mohammad Azam <m.azam@samsung.com>
 MohammadSabri <mohammad.kh.sabri@exalt.ps>
-Mohammed Ashraf <mohammedashraf4599@gmail.com>
 Mohammed Wajahat Ali Siddiqui <wajahat.s@samsung.com>
 Mohan Reddy <mohan.reddy@samsung.com>
 Mohit Bhalla <bhallam@amazon.com>
@@ -1312,7 +1310,6 @@ Serhii Matrunchyk <sergiy.matrunchyk@gmail.com>
 Seshadri Mahalingam <seshadri.mahalingam@gmail.com>
 Seungkyu Lee <zx6658@gmail.com>
 Sevan Janiyan <venture37@geeklan.co.uk>
-Shaheen Fazim <fazim.pentester@gmail.com>
 Shahriar Rostami <shahriar.rostami@gmail.com>
 Shail Singhal <shail.s@samsung.com>
 Shane Hansen <shanemhansen@gmail.com>

src/base/BUILD.gn

@@ -25,6 +25,7 @@ import("//build/buildflag_header.gni")
 import("//build/config/arm.gni")
 import("//build/config/c++/c++.gni")
 import("//build/config/cast.gni")
+import("//build/config/chromeos/ui_mode.gni")
 import("//build/config/compiler/compiler.gni")
 import("//build/config/cronet/config.gni")
 import("//build/config/dcheck_always_on.gni")
@@ -40,7 +41,7 @@ import("//build/util/process_version.gni")
 import("//build_overrides/build.gni")
 
 if (is_ios) {
-  # Used to access target_environment and target_platform.
+  # Used to access target_environment.
   import("//build/config/apple/mobile_config.gni")
 
   # Used to access ios_is_app_extension variable definition.
@@ -243,6 +244,8 @@ component("base") {
     "containers/unique_ptr_adapters.h",
     "containers/util.h",
     "containers/vector_buffer.h",
+    "cpu_reduction_experiment.cc",
+    "cpu_reduction_experiment.h",
     "critical_closure.h",
     "dcheck_is_on.h",
     "debug/alias.cc",
@@ -558,8 +561,6 @@ component("base") {
     "run_loop.h",
     "sampling_heap_profiler/lock_free_address_hash_set.cc",
     "sampling_heap_profiler/lock_free_address_hash_set.h",
-    "sampling_heap_profiler/lock_free_bloom_filter.cc",
-    "sampling_heap_profiler/lock_free_bloom_filter.h",
     "sampling_heap_profiler/poisson_allocation_sampler.cc",
     "sampling_heap_profiler/poisson_allocation_sampler.h",
     "sampling_heap_profiler/sampling_heap_profiler.cc",
@@ -584,7 +585,6 @@ component("base") {
     "strings/abseil_string_number_conversions.cc",
     "strings/abseil_string_number_conversions.h",
     "strings/cstring_view.h",
-    "strings/durable_string_view.h",
     "strings/escape.cc",
     "strings/escape.h",
     "strings/latin1_string_conversions.cc",
@@ -868,8 +868,6 @@ component("base") {
     "trace_event/heap_profiler_allocation_context.h",
     "trace_event/heap_profiler_allocation_context_tracker.cc",
     "trace_event/heap_profiler_allocation_context_tracker.h",
-    "trace_event/histogram_scope.cc",
-    "trace_event/histogram_scope.h",
     "trace_event/memory_allocator_dump_guid.cc",
     "trace_event/memory_allocator_dump_guid.h",
     "trace_event/named_trigger.cc",
@@ -896,7 +894,6 @@ component("base") {
     "types/same_as_any.h",
     "types/strong_alias.h",
     "types/supports_ostream_operator.h",
-    "types/supports_to_string.h",
     "types/to_address.h",
     "types/token_type.h",
     "types/variant_util.h",
@@ -1062,13 +1059,10 @@ component("base") {
     "//base/numerics:base_numerics",
     "//base/third_party/icu",
     "//build:chromecast_buildflags",
+    "//build:chromeos_buildflags",
     "//third_party/abseil-cpp:absl",
   ]
 
-  # TODO(crbug.com/354842935): Remove this dependency once other modules don't
-  # accidentally (transitively) depend on it anymore.
-  public_deps += [ "//build:chromeos_buildflags" ]
-
   # Needed for <atomic> if using newer C++ library than sysroot, except if
   # building inside the cros_sdk environment - use host_toolchain as a
   # more robust check for this.
@@ -1188,6 +1182,7 @@ component("base") {
   if (is_robolectric) {
     # Make jni.h available.
     configs += [ "//third_party/jdk" ]
+    deps += [ ":base_robolectric_jni" ]
   }
   if (is_robolectric) {
     sources += [
@@ -1196,8 +1191,6 @@ component("base") {
       "android/callback_android.cc",
       "android/callback_android.h",
       "android/command_line_android.cc",
-      "android/int_string_callback.cc",
-      "android/int_string_callback.h",
       "android/java_exception_reporter.cc",
       "android/java_exception_reporter.h",
       "android/jni_android.cc",
@@ -1215,13 +1208,8 @@ component("base") {
       "android/jni_utils.cc",
       "android/jni_utils.h",
       "android/jni_weak_ref.h",
-      "android/library_loader/anchor_functions.cc",
-      "android/library_loader/anchor_functions.h",
       "android/library_loader/library_loader_hooks.cc",
       "android/library_loader/library_loader_hooks.h",
-      "android/library_loader/library_prefetcher.cc",
-      "android/library_loader/library_prefetcher.h",
-      "android/library_loader/library_prefetcher_hooks.cc",
       "android/native_uma_recorder.cc",
       "android/scoped_java_ref.h",
       "android/token_android.cc",
@@ -1894,8 +1882,8 @@ component("base") {
       "apple/call_with_eh_frame.cc",
       "apple/call_with_eh_frame.h",
       "apple/call_with_eh_frame_asm.S",
-      "apple/dispatch_source.cc",
-      "apple/dispatch_source.h",
+      "apple/dispatch_source_mach.cc",
+      "apple/dispatch_source_mach.h",
       "apple/foundation_util.h",
       "apple/foundation_util.mm",
       "apple/mach_logging.cc",
@@ -1926,9 +1914,10 @@ component("base") {
       "message_loop/message_pump_apple.h",
       "message_loop/message_pump_apple.mm",
       "native_library_apple.mm",
-      "process/process_metrics_apple.mm",
+      "process/process_metrics_apple.cc",
       "profiler/module_cache_apple.cc",
       "strings/sys_string_conversions_apple.mm",
+      "synchronization/waitable_event_apple.cc",
       "system/sys_info_apple.mm",
       "threading/platform_thread_apple.mm",
       "time/time_apple.mm",
@@ -1940,10 +1929,6 @@ component("base") {
       "Foundation.framework",
       "Security.framework",
     ]
-
-    if (!is_ios || !use_blink) {
-      sources += [ "synchronization/waitable_event_apple.cc" ]
-    }
   }
 
   # Desktop Mac.
@@ -2080,20 +2065,12 @@ component("base") {
         "process/process_handle_mac.cc",
         "process/process_ios.cc",
         "process/process_iterator_mac.cc",
+        "process/process_mac.cc",
         "process/process_posix.cc",
         "sync_socket_posix.cc",
-        "synchronization/waitable_event_posix.cc",
-        "synchronization/waitable_event_watcher_posix.cc",
+        "synchronization/waitable_event_watcher_mac.cc",
       ]
 
-      if (target_platform == "tvos") {
-        # tvOS apps must be single-process. Build a Process version that does
-        # the bare minimum and does not use Mach ports.
-        sources += [ "process/process_tvos.cc" ]
-      } else {
-        sources += [ "process/process_mac.cc" ]
-      }
-
       # We include launch_mac on simulator builds so unittests can fork.
       if (target_environment == "simulator") {
         sources += [
@@ -2116,11 +2093,6 @@ component("base") {
         "message_loop/message_pump_io_ios.cc",
         "message_loop/message_pump_io_ios.h",
       ]
-    } else if (use_blink) {
-      sources += [
-        "message_loop/message_pump_io_ios_libdispatch.cc",
-        "message_loop/message_pump_io_ios_libdispatch.h",
-      ]
     } else {
       sources += [
         "message_loop/message_pump_kqueue.cc",
@@ -2276,6 +2248,7 @@ component("base") {
   if (enable_base_tracing) {
     sources += [
       "trace_event/auto_open_close_event.h",
+      "trace_event/builtin_categories.cc",
       "trace_event/builtin_categories.h",
       "trace_event/heap_profiler.h",
       "trace_event/interned_args_helper.cc",
@@ -2478,7 +2451,7 @@ buildflag_header("debugging_buildflags") {
 buildflag_header("feature_list_buildflags") {
   header = "feature_list_buildflags.h"
 
-  if (is_chromeos) {
+  if (is_chromeos_ash) {
     flags = [
       "ENABLE_BANNED_BASE_FEATURE_PREFIX=true",
       "BANNED_BASE_FEATURE_PREFIX=\"CrOSLateBoot\"",
@@ -2600,7 +2573,10 @@ static_library("base_static") {
     "immediate_crash.h",
   ]
 
-  deps = [ ":fuzzing_buildflags" ]
+  deps = [
+    ":fuzzing_buildflags",
+    "//build:chromeos_buildflags",
+  ]
 
   if (is_win) {
     sources += [

src/base/allocator/partition_alloc_features.cc

@@ -12,6 +12,7 @@
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "build/chromecast_buildflags.h"
+#include "build/chromeos_buildflags.h"
 #include "partition_alloc/buildflags.h"
 #include "partition_alloc/partition_alloc_base/time/time.h"
 #include "partition_alloc/partition_alloc_constants.h"
@@ -273,15 +274,16 @@ BASE_FEATURE(kPartitionAllocPermissiveMte,
 #endif
 );
 
-BASE_FEATURE(kAsanBrpDereferenceCheck,
-             "AsanBrpDereferenceCheck",
-             FEATURE_ENABLED_BY_DEFAULT);
-BASE_FEATURE(kAsanBrpExtractionCheck,
-             "AsanBrpExtractionCheck",      // Not much noise at the moment to
-             FEATURE_DISABLED_BY_DEFAULT);  // enable by default.
-BASE_FEATURE(kAsanBrpInstantiationCheck,
-             "AsanBrpInstantiationCheck",
-             FEATURE_ENABLED_BY_DEFAULT);
+// Note: Do not use the prepared macro to implement following FeatureParams
+// as of no need for a local cache.
+constinit const FeatureParam<bool> kBackupRefPtrAsanEnableDereferenceCheckParam{
+    &kPartitionAllocBackupRefPtr, "asan-enable-dereference-check", true};
+constinit const FeatureParam<bool> kBackupRefPtrAsanEnableExtractionCheckParam{
+    &kPartitionAllocBackupRefPtr, "asan-enable-extraction-check",
+    false};  // Not much noise at the moment to enable by default.
+constinit const FeatureParam<bool>
+    kBackupRefPtrAsanEnableInstantiationCheckParam{
+        &kPartitionAllocBackupRefPtr, "asan-enable-instantiation-check", true};
 
 // If enabled, switches the bucket distribution to a denser one.
 //
@@ -466,6 +468,12 @@ BASE_FEATURE(kPartitionAllocDisableBRPInBufferPartition,
              "PartitionAllocDisableBRPInBufferPartition",
              FEATURE_DISABLED_BY_DEFAULT);
 
+#if PA_BUILDFLAG(USE_FREELIST_DISPATCHER)
+BASE_FEATURE(kUsePoolOffsetFreelists,
+             "PartitionAllocUsePoolOffsetFreelists",
+             FEATURE_ENABLED_BY_DEFAULT);
+#endif
+
 BASE_FEATURE(kPartitionAllocAdjustSizeWhenInForeground,
              "PartitionAllocAdjustSizeWhenInForeground",
 #if BUILDFLAG(IS_MAC) || BUILDFLAG(IS_WIN)

src/base/allocator/partition_alloc_features.h

@@ -162,9 +162,15 @@ BASE_EXPORT BASE_DECLARE_FEATURE_PARAM(MemoryTaggingEnabledProcesses,
 // enabled.
 BASE_EXPORT BASE_DECLARE_FEATURE(kKillPartitionAllocMemoryTagging);
 BASE_EXPORT BASE_DECLARE_FEATURE(kPartitionAllocPermissiveMte);
-BASE_EXPORT BASE_DECLARE_FEATURE(kAsanBrpDereferenceCheck);
-BASE_EXPORT BASE_DECLARE_FEATURE(kAsanBrpExtractionCheck);
-BASE_EXPORT BASE_DECLARE_FEATURE(kAsanBrpInstantiationCheck);
+BASE_EXPORT BASE_DECLARE_FEATURE_PARAM(
+    bool,
+    kBackupRefPtrAsanEnableDereferenceCheckParam);
+BASE_EXPORT BASE_DECLARE_FEATURE_PARAM(
+    bool,
+    kBackupRefPtrAsanEnableExtractionCheckParam);
+BASE_EXPORT BASE_DECLARE_FEATURE_PARAM(
+    bool,
+    kBackupRefPtrAsanEnableInstantiationCheckParam);
 BASE_EXPORT BASE_DECLARE_FEATURE_PARAM(BucketDistributionMode,
                                        kPartitionAllocBucketDistributionParam);
 
@@ -210,6 +216,13 @@ BASE_EXPORT int GetThreadCacheMinCachedMemoryForPurgingBytes();
 
 BASE_EXPORT BASE_DECLARE_FEATURE(kPartitionAllocDisableBRPInBufferPartition);
 
+// This feature is additionally gated behind a buildflag because
+// pool offset freelists cannot be represented when PartitionAlloc uses
+// 32-bit pointers.
+#if PA_BUILDFLAG(USE_FREELIST_DISPATCHER)
+BASE_EXPORT BASE_DECLARE_FEATURE(kUsePoolOffsetFreelists);
+#endif
+
 // When set, partitions use a larger ring buffer and free memory less
 // aggressively when in the foreground.
 BASE_EXPORT BASE_DECLARE_FEATURE(kPartitionAllocAdjustSizeWhenInForeground);

src/base/allocator/partition_alloc_support.cc

@@ -107,9 +107,12 @@ BootloaderOverride GetBootloaderOverride() {
 }
 #endif
 
-// Avoid running periodic purging or reclaim for the first minute after the
-// first attempt. This is based on the insight that processes often don't live
-// paste this minute.
+// When under this experiment avoid running periodic purging or reclaim for the
+// first minute after the first attempt. This is based on the insight that
+// processes often don't live paste this minute.
+static BASE_FEATURE(kDelayFirstPeriodicPAPurgeOrReclaim,
+                    "DelayFirstPeriodicPAPurgeOrReclaim",
+                    base::FEATURE_ENABLED_BY_DEFAULT);
 constexpr base::TimeDelta kFirstPAPurgeOrReclaimDelay = base::Minutes(1);
 
 // This is defined in content/public/common/content_switches.h, which is not
@@ -168,8 +171,6 @@ void MemoryReclaimerSupport::Start(scoped_refptr<TaskRunner> task_runner) {
     return;
   }
 
-  task_runner_ = task_runner;
-
   // The caller of the API fully controls where running the reclaim.
   // However there are a few reasons to recommend that the caller runs
   // it on the main thread:
@@ -185,7 +186,13 @@ void MemoryReclaimerSupport::Start(scoped_refptr<TaskRunner> task_runner) {
   // seconds is useful. Since this is meant to run during idle time only, it is
   // a reasonable starting point balancing effectivenes vs cost. See
   // crbug.com/942512 for details and experimental results.
-  MaybeScheduleTask(kFirstPAPurgeOrReclaimDelay);
+  TimeDelta delay;
+  if (base::FeatureList::IsEnabled(kDelayFirstPeriodicPAPurgeOrReclaim)) {
+    delay = std::max(delay, kFirstPAPurgeOrReclaimDelay);
+  }
+
+  task_runner_ = task_runner;
+  MaybeScheduleTask(delay);
 }
 
 void MemoryReclaimerSupport::SetForegrounded(bool in_foreground) {
@@ -246,9 +253,12 @@ void MemoryReclaimerSupport::MaybeScheduleTask(TimeDelta delay) {
 
 void StartThreadCachePeriodicPurge() {
   auto& instance = ::partition_alloc::ThreadCacheRegistry::Instance();
-  TimeDelta delay = std::max(
-      Microseconds(instance.GetPeriodicPurgeNextIntervalInMicroseconds()),
-      kFirstPAPurgeOrReclaimDelay);
+  TimeDelta delay =
+      Microseconds(instance.GetPeriodicPurgeNextIntervalInMicroseconds());
+
+  if (base::FeatureList::IsEnabled(kDelayFirstPeriodicPAPurgeOrReclaim)) {
+    delay = std::max(delay, kFirstPAPurgeOrReclaimDelay);
+  }
 
   SingleThreadTaskRunner::GetCurrentDefault()->PostDelayedTask(
       FROM_HERE, BindOnce(RunThreadCachePeriodicPurge), delay);
@@ -1003,17 +1013,18 @@ void PartitionAllocSupport::ReconfigureAfterFeatureListInit(
   if (ShouldEnableFeatureOnProcess(
           base::features::kBackupRefPtrEnabledProcessesParam.Get(),
           process_type)) {
-    RawPtrAsanService::GetInstance().Configure(
-        EnableDereferenceCheck(
-            FeatureList::IsEnabled(features::kAsanBrpDereferenceCheck)),
-        EnableExtractionCheck(
-            FeatureList::IsEnabled(features::kAsanBrpExtractionCheck)),
-        EnableInstantiationCheck(
-            FeatureList::IsEnabled(features::kAsanBrpInstantiationCheck)));
+    base::RawPtrAsanService::GetInstance().Configure(
+        base::EnableDereferenceCheck(
+            base::features::kBackupRefPtrAsanEnableDereferenceCheckParam.Get()),
+        base::EnableExtractionCheck(
+            base::features::kBackupRefPtrAsanEnableExtractionCheckParam.Get()),
+        base::EnableInstantiationCheck(
+            base::features::kBackupRefPtrAsanEnableInstantiationCheckParam
+                .Get()));
   } else {
-    RawPtrAsanService::GetInstance().Configure(EnableDereferenceCheck(false),
-                                               EnableExtractionCheck(false),
-                                               EnableInstantiationCheck(false));
+    base::RawPtrAsanService::GetInstance().Configure(
+        base::EnableDereferenceCheck(false), base::EnableExtractionCheck(false),
+        base::EnableInstantiationCheck(false));
   }
 #endif  // PA_BUILDFLAG(USE_ASAN_BACKUP_REF_PTR)
 
@@ -1043,6 +1054,13 @@ void PartitionAllocSupport::ReconfigureAfterFeatureListInit(
   const bool fewer_memory_regions = base::FeatureList::IsEnabled(
       base::features::kPartitionAllocFewerMemoryRegions);
 
+#if PA_BUILDFLAG(USE_FREELIST_DISPATCHER)
+  const bool use_pool_offset_freelists =
+      base::FeatureList::IsEnabled(base::features::kUsePoolOffsetFreelists);
+#else
+  const bool use_pool_offset_freelists = false;
+#endif  // PA_BUILDFLAG(USE_FREELIST_DISPATCHER)
+
   bool enable_memory_tagging = false;
   partition_alloc::TagViolationReportingMode memory_tagging_reporting_mode =
       partition_alloc::TagViolationReportingMode::kUndefined;
@@ -1145,6 +1163,7 @@ void PartitionAllocSupport::ReconfigureAfterFeatureListInit(
       allocator_shim::ZappingByFreeFlags(zapping_by_free_flags),
       allocator_shim::EventuallyZeroFreedMemory(eventually_zero_freed_memory),
       allocator_shim::FewerMemoryRegions(fewer_memory_regions),
+      allocator_shim::UsePoolOffsetFreelists(use_pool_offset_freelists),
       use_small_single_slot_spans);
 
   const uint32_t extras_size = allocator_shim::GetMainPartitionRootExtrasSize();

src/base/allocator/partition_allocator/gn/BUILDCONFIG.gn

@@ -52,6 +52,7 @@ is_nacl = false
 is_win = current_os == "win" || current_os == "winuwp"
 is_cast_android = false
 is_castos = false
+is_chromeos_ash = false
 is_cronet_build = false
 enable_expensive_dchecks = false
 dcheck_is_configurable = false

src/base/allocator/partition_allocator/src/partition_alloc/BUILD.gn

@@ -123,34 +123,12 @@ source_set("buildflag_macro") {
   public_configs = [ ":public_includes" ]
 }
 
-# When developers are repeatedly growing a buffer with `realloc`, they are
-# expected to request a new size that is larger than the current size by
-# some growth factor. This growth factor allows to amortize the cost of
-# memcpy. Unfortunately, some nVidia drivers have a bug where they repeatedly
-# increase the buffer by 4144 byte only.
-#
-# In particular, most Skia Linux bots are using the affected nVidia driver. So
-# this flag is used as a workaround for Skia standalone, not in production.
-#
-# External link:
-#   https://forums.developer.nvidia.com/t/550-54-14-very-bad-performance-due-to-bunch-of-reallocations-during-glcore-initialization/287027
-#
-# Internal discussion at @chrome-memory-safety:
-#   https://groups.google.com/a/google.com/d/msgid/chrome-memory-safety/CAAzos5HrexY2njz2YzWrffTq1xEfkx15GVpSvHUyQED6wBSXvA%40mail.gmail.com?utm_medium=email&utm_source=footer
-declare_args() {
-  partition_alloc_realloc_growth_factor_mitigation = false
-}
-
 pa_buildflag_header("buildflags") {
   header = "buildflags.h"
   flags = [
     "ASSERT_CPP_20=$assert_cpp20",
     "BACKUP_REF_PTR_EXTRA_OOB_CHECKS=$backup_ref_ptr_extra_oob_checks",
     "BACKUP_REF_PTR_POISON_OOB_PTR=$backup_ref_ptr_poison_oob_ptr",
-    "CAN_UNWIND_WITH_FRAME_POINTERS=$can_unwind_with_frame_pointers",
-    "DCHECKS_ARE_ON=$partition_alloc_dchecks_are_on",
-    "DCHECK_IS_CONFIGURABLE=$dcheck_is_configurable",
-    "ENABLE_ALLOCATOR_SHIM_PARTITION_ALLOC_DISPATCH_WITH_ADVANCED_CHECKS_SUPPORT=$enable_allocator_shim_partition_alloc_dispatch_with_advanced_checks_support",
     "ENABLE_BACKUP_REF_PTR_FEATURE_FLAG=$enable_backup_ref_ptr_feature_flag",
     "ENABLE_BACKUP_REF_PTR_INSTANCE_TRACER=$enable_backup_ref_ptr_instance_tracer",
     "ENABLE_BACKUP_REF_PTR_SLOW_CHECKS=$enable_backup_ref_ptr_slow_checks",
@@ -165,7 +143,6 @@ pa_buildflag_header("buildflags") {
     "ENABLE_POINTER_SUBTRACTION_CHECK=$enable_pointer_subtraction_check",
     "ENABLE_SHADOW_METADATA_FOR_64_BITS_POINTERS=$enable_shadow_metadata",
     "ENABLE_THREAD_ISOLATION=$enable_pkeys",
-    "EXPENSIVE_DCHECKS_ARE_ON=$enable_expensive_dchecks",
     "FORCE_DISABLE_BACKUP_REF_PTR_FEATURE=$force_disable_backup_ref_ptr_feature",
     "FORCE_ENABLE_RAW_PTR_EXCLUSION=$force_enable_raw_ptr_exclusion",
     "FORWARD_THROUGH_MALLOC=$forward_through_malloc",
@@ -179,7 +156,6 @@ pa_buildflag_header("buildflags") {
     "RAW_PTR_ZERO_ON_CONSTRUCT=$raw_ptr_zero_on_construct",
     "RAW_PTR_ZERO_ON_DESTRUCT=$raw_ptr_zero_on_destruct",
     "RAW_PTR_ZERO_ON_MOVE=$raw_ptr_zero_on_move",
-    "REALLOC_GROWTH_FACTOR_MITIGATION=$partition_alloc_realloc_growth_factor_mitigation",
     "RECORD_ALLOC_INFO=$record_alloc_info",
     "SMALLER_PARTITION_COOKIE=$smaller_partition_cookie",
     "STACK_SCAN_SUPPORTED=$stack_scan_supported",
@@ -195,6 +171,11 @@ pa_buildflag_header("buildflags") {
     "USE_RAW_PTR_ASAN_UNOWNED_IMPL=$use_raw_ptr_asan_unowned_impl",
     "USE_RAW_PTR_BACKUP_REF_IMPL=$use_raw_ptr_backup_ref_impl",
     "USE_RAW_PTR_HOOKABLE_IMPL=$use_raw_ptr_hookable_impl",
+    "ENABLE_ALLOCATOR_SHIM_PARTITION_ALLOC_DISPATCH_WITH_ADVANCED_CHECKS_SUPPORT=$enable_allocator_shim_partition_alloc_dispatch_with_advanced_checks_support",
+    "DCHECKS_ARE_ON=$partition_alloc_dchecks_are_on",
+    "EXPENSIVE_DCHECKS_ARE_ON=$enable_expensive_dchecks",
+    "DCHECK_IS_CONFIGURABLE=$dcheck_is_configurable",
+    "CAN_UNWIND_WITH_FRAME_POINTERS=$can_unwind_with_frame_pointers",
   ]
 }
 

src/base/allocator/partition_allocator/src/partition_alloc/page_allocator_internals_posix.cc

@@ -200,7 +200,14 @@ bool UseMapJit() {
 }
 #elif PA_BUILDFLAG(IS_IOS)
 bool UseMapJit() {
+// Always enable MAP_JIT in simulator as it is supported unconditionally.
+#if TARGET_IPHONE_SIMULATOR
   return true;
+#else
+  // TODO(crbug.com/40255826): Fill this out when the API it is
+  // available.
+  return false;
+#endif  // TARGET_IPHONE_SIMULATOR
 }
 #endif  // PA_BUILDFLAG(IS_IOS)
 

src/base/allocator/partition_allocator/src/partition_alloc/page_allocator_internals_posix.h

@@ -83,13 +83,6 @@ uintptr_t SystemAllocPagesInternal(uintptr_t hint,
           PageAccessibilityConfiguration::kInaccessibleWillJitLater &&
       kUseMapJit) {
     map_flags |= MAP_JIT;
-    // iOS devices do not support toggling the page permissions after a MAP_JIT
-    // call, they must be set initially. iOS has per-thread W^X state that
-    // takes precedence over the mapping's permissions for MAP_JIT regions.
-    // See https://developer.apple.com/forums/thread/672804
-#if PA_BUILDFLAG(IS_IOS)
-    access_flag = PROT_READ | PROT_WRITE | PROT_EXEC;
-#endif
   }
 #endif
 

src/base/allocator/partition_allocator/src/partition_alloc/partition_alloc-inl.h

@@ -65,7 +65,7 @@ PA_ALWAYS_INLINE void DebugMemset(void* ptr, int value, size_t size) {
   // faster. Note that for direct-mapped allocations, memory is decomitted at
   // free() time, so freed memory usage cannot happen.
 
-#if PA_BUILDFLAG(ENABLE_THREAD_ISOLATION) && PA_BUILDFLAG(ENABLE_PKEYS)
+#if PA_BUILDFLAG(ENABLE_THREAD_ISOLATION)
   LiftThreadIsolationScope lift_thread_isolation_restrictions;
 #endif
   size_t size_to_memset = std::min(size, size_t{1} << 19);

src/base/allocator/partition_allocator/src/partition_alloc/partition_alloc_base/strings/cstring_builder.h

@@ -7,8 +7,13 @@
 
 #include <cstddef>
 
+#include "partition_alloc/build_config.h"
 #include "partition_alloc/partition_alloc_base/component_export.h"
 
+#if !PA_BUILDFLAG(IS_WIN)
+#include <unistd.h>
+#endif
+
 namespace partition_alloc::internal::base::strings {
 
 // Similar to std::ostringstream, but creates a C string, i.e. nul-terminated

src/base/allocator/partition_allocator/src/partition_alloc/partition_root.h

@@ -2478,7 +2478,7 @@ void* PartitionRoot::ReallocInline(void* ptr,
   constexpr bool no_hooks = ContainsFlags(alloc_flags, AllocFlags::kNoHooks);
   const bool hooks_enabled = PartitionAllocHooks::AreHooksEnabled();
   bool overridden = false;
-  size_t old_usable_size = 0;
+  size_t old_usable_size;
   if (!no_hooks && hooks_enabled) [[unlikely]] {
     overridden = PartitionAllocHooks::ReallocOverrideHookIfEnabled(
         &old_usable_size, ptr);
@@ -2521,21 +2521,6 @@ void* PartitionRoot::ReallocInline(void* ptr,
     }
   }
 
-#if PA_BUILDFLAG(REALLOC_GROWTH_FACTOR_MITIGATION)
-  // Some nVidia drivers have a performance bug where they repeatedly realloc a
-  // buffer with a small 4144 byte increment instead of using a growth factor to
-  // amortize the cost of a memcpy. To work around this, we apply a growth
-  // factor to the new size to avoid this issue. This workaround is only
-  // intended to be used for Skia bots, and is not intended to be a general
-  // solution.
-  if (new_size > old_usable_size && new_size > 12 << 20) {
-    // 1.5x growth factor.
-    // Note that in case of integer overflow, the std::max ensures that the
-    // new_size is at least as large as the old_usable_size.
-    new_size = std::max(new_size, old_usable_size * 3 / 2);
-  }
-#endif
-
   // This realloc cannot be resized in-place. Sadness.
   void* ret = AllocInternal<alloc_flags>(
       new_size, internal::PartitionPageSize(), type_name);

src/base/allocator/partition_allocator/src/partition_alloc/pointers/raw_ptr.h

@@ -1255,7 +1255,6 @@ struct pointer_traits<::raw_ptr<T, Traits>> {
   }
 };
 
-#if PA_BUILDFLAG(ASSERT_CPP_20)
 // Mark `raw_ptr<T>` and `T*` as having a common reference type (the type to
 // which both can be converted or bound) of `T*`. This makes them satisfy
 // `std::equality_comparable`, which allows usage like:
@@ -1268,20 +1267,23 @@ struct pointer_traits<::raw_ptr<T, Traits>> {
 // error about being unable to invoke `std::ranges::equal_to()`.
 template <typename T,
           base::RawPtrTraits Traits,
-          template <typename> typename TQ,
-          template <typename> typename UQ>
-struct basic_common_reference<raw_ptr<T, Traits>, T*, TQ, UQ> {
+          template <typename>
+          typename TQ,
+          template <typename>
+          typename UQ>
+struct std::basic_common_reference<raw_ptr<T, Traits>, T*, TQ, UQ> {
   using type = T*;
 };
 
 template <typename T,
           base::RawPtrTraits Traits,
-          template <typename> typename TQ,
-          template <typename> typename UQ>
-struct basic_common_reference<T*, raw_ptr<T, Traits>, TQ, UQ> {
+          template <typename>
+          typename TQ,
+          template <typename>
+          typename UQ>
+struct std::basic_common_reference<T*, raw_ptr<T, Traits>, TQ, UQ> {
   using type = T*;
 };
-#endif  // PA_BUILDFLAG(ASSERT_CPP_20)
 
 }  // namespace std
 

src/base/allocator/partition_allocator/src/partition_alloc/shim/allocator_shim.h

@@ -153,6 +153,9 @@ using EventuallyZeroFreedMemory = partition_alloc::internal::base::
 using FewerMemoryRegions =
     partition_alloc::internal::base::StrongAlias<class FewerMemoryRegionsTag,
                                                  bool>;
+using UsePoolOffsetFreelists = partition_alloc::internal::base::
+    StrongAlias<class UsePoolOffsetFreelistsTag, bool>;
+
 using UseSmallSingleSlotSpans = partition_alloc::internal::base::
     StrongAlias<class UseSmallSingleSlotSpansTag, bool>;
 
@@ -171,6 +174,7 @@ void ConfigurePartitions(
     ZappingByFreeFlags zapping_by_free_flags,
     EventuallyZeroFreedMemory eventually_zero_freed_memory,
     FewerMemoryRegions fewer_memory_regions,
+    UsePoolOffsetFreelists use_pool_offset_freelists,
     UseSmallSingleSlotSpans use_small_single_slot_spans);
 
 PA_COMPONENT_EXPORT(ALLOCATOR_SHIM) uint32_t GetMainPartitionRootExtrasSize();

src/base/allocator/partition_allocator/src/partition_alloc/shim/allocator_shim_default_dispatch_to_partition_alloc.cc

@@ -620,6 +620,7 @@ void ConfigurePartitions(
     ZappingByFreeFlags zapping_by_free_flags,
     EventuallyZeroFreedMemory eventually_zero_freed_memory,
     FewerMemoryRegions fewer_memory_regions,
+    UsePoolOffsetFreelists use_pool_offset_freelists,
     UseSmallSingleSlotSpans use_small_single_slot_spans) {
   // Calling Get() is actually important, even if the return value isn't
   // used, because it has a side effect of initializing the variable, if it
@@ -667,7 +668,9 @@ void ConfigurePartitions(
                            : partition_alloc::PartitionOptions::kDisabled,
             .reporting_mode = memory_tagging_reporting_mode};
         opts.use_pool_offset_freelists =
-            partition_alloc::PartitionOptions::kEnabled;
+            use_pool_offset_freelists
+                ? partition_alloc::PartitionOptions::kEnabled
+                : partition_alloc::PartitionOptions::kDisabled;
         opts.use_small_single_slot_spans =
             use_small_single_slot_spans
                 ? partition_alloc::PartitionOptions::kEnabled

src/base/allocator/partition_allocator/src/partition_alloc/shim/allocator_shim_default_dispatch_to_partition_alloc.h

@@ -181,14 +181,15 @@ PA_ALWAYS_INLINE void ConfigurePartitionsForTesting() {
   auto zapping_by_free_flags = ZappingByFreeFlags(false);
   auto eventually_zero_freed_memory = EventuallyZeroFreedMemory(false);
   auto fewer_memory_regions = FewerMemoryRegions(false);
+  auto use_pool_offset_freelists = UsePoolOffsetFreelists(true);
   auto use_small_single_slot_spans = UseSmallSingleSlotSpans(true);
 
-  ConfigurePartitions(enable_brp, brp_extra_extras_size, enable_memory_tagging,
-                      memory_tagging_reporting_mode, distribution,
-                      scheduler_loop_quarantine,
-                      scheduler_loop_quarantine_capacity_in_bytes,
-                      zapping_by_free_flags, eventually_zero_freed_memory,
-                      fewer_memory_regions, use_small_single_slot_spans);
+  ConfigurePartitions(
+      enable_brp, brp_extra_extras_size, enable_memory_tagging,
+      memory_tagging_reporting_mode, distribution, scheduler_loop_quarantine,
+      scheduler_loop_quarantine_capacity_in_bytes, zapping_by_free_flags,
+      eventually_zero_freed_memory, fewer_memory_regions,
+      use_pool_offset_freelists, use_small_single_slot_spans);
 }
 #endif  // PA_BUILDFLAG(USE_PARTITION_ALLOC_AS_MALLOC)
 

src/base/android/android_info.cc

@@ -1,196 +0,0 @@
-// Copyright 2025 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/android/android_info.h"
-
-#include <cstring>
-#include <mutex>
-#include <string>
-#include <variant>
-
-#include "base/android/jni_android.h"
-#include "base/android/jni_array.h"
-#include "base/android/jni_string.h"
-#include "base/android/scoped_java_ref.h"
-#include "base/check.h"
-#include "base/strings/string_number_conversions.h"
-
-// Must come after all headers that specialize FromJniType() / ToJniType().
-#include "base/android_info_jni/AndroidInfo_jni.h"
-
-namespace base::android::android_info {
-
-namespace {
-
-struct AndroidInfo {
-  // Const char* is used instead of std::strings because these values must be
-  // available even if the process is in a crash state. Sadly
-  // std::string.c_str() doesn't guarantee that memory won't be allocated when
-  // it is called.
-  const char* device;
-
-  const char* manufacturer;
-
-  const char* model;
-
-  const char* brand;
-
-  const char* android_build_id;
-
-  const char* build_type;
-
-  const char* board;
-
-  const char* android_build_fp;
-
-  int sdk_int;
-
-  bool is_debug_android;
-
-  const char* version_incremental;
-
-  const char* hardware;
-
-  bool is_at_least_u;
-
-  const char* codename;
-
-  // Available only on android S+. For S-, this method returns empty string.
-  const char* soc_manufacturer;
-
-  bool is_at_least_t;
-
-  const char* abi_name;
-};
-
-std::optional<AndroidInfo> holder;
-
-const AndroidInfo& get_android_info() {
-  [[maybe_unused]] static auto once = [] {
-    Java_AndroidInfo_nativeReadyForFields(AttachCurrentThread());
-    return std::monostate();
-  }();
-  // holder should be initialized as the java is supposed to call the native
-  // method FillFields which will initialize the fields within the holder.
-  DCHECK(holder.has_value());
-  return *holder;
-}
-
-}  // namespace
-
-static void JNI_AndroidInfo_FillFields(
-    JNIEnv* env,
-    const jni_zero::JavaParamRef<jstring>& brand,
-    const jni_zero::JavaParamRef<jstring>& device,
-    const jni_zero::JavaParamRef<jstring>& buildId,
-    const jni_zero::JavaParamRef<jstring>& manufacturer,
-    const jni_zero::JavaParamRef<jstring>& model,
-    const jni_zero::JavaParamRef<jstring>& type,
-    const jni_zero::JavaParamRef<jstring>& board,
-    const jni_zero::JavaParamRef<jstring>& androidBuildFingerprint,
-    const jni_zero::JavaParamRef<jstring>& versionIncremental,
-    const jni_zero::JavaParamRef<jstring>& hardware,
-    const jni_zero::JavaParamRef<jstring>& codeName,
-    const jni_zero::JavaParamRef<jstring>& socManufacturer,
-    const jni_zero::JavaParamRef<jstring>& supportedAbis,
-    jint sdkInt,
-    jboolean isDebugAndroid,
-    jboolean isAtleastU,
-    jboolean isAtleastT) {
-  DCHECK(!holder.has_value());
-  auto java_string_to_const_char =
-      [](const jni_zero::JavaParamRef<jstring>& str) {
-        return strdup(ConvertJavaStringToUTF8(str).c_str());
-      };
-  holder = AndroidInfo{
-      .device = java_string_to_const_char(device),
-      .manufacturer = java_string_to_const_char(manufacturer),
-      .model = java_string_to_const_char(model),
-      .brand = java_string_to_const_char(brand),
-      .android_build_id = java_string_to_const_char(buildId),
-      .build_type = java_string_to_const_char(type),
-      .board = java_string_to_const_char(board),
-      .android_build_fp = java_string_to_const_char(androidBuildFingerprint),
-      .sdk_int = sdkInt,
-      .is_debug_android = static_cast<bool>(isDebugAndroid),
-      .version_incremental = java_string_to_const_char(versionIncremental),
-      .hardware = java_string_to_const_char(hardware),
-      .is_at_least_u = static_cast<bool>(isAtleastU),
-      .codename = java_string_to_const_char(codeName),
-      .soc_manufacturer = java_string_to_const_char(socManufacturer),
-      .is_at_least_t = static_cast<bool>(isAtleastT),
-      .abi_name = java_string_to_const_char(supportedAbis),
-  };
-}
-
-const char* device() {
-  return get_android_info().device;
-}
-
-const char* manufacturer() {
-  return get_android_info().manufacturer;
-}
-
-const char* model() {
-  return get_android_info().model;
-}
-
-const char* brand() {
-  return get_android_info().brand;
-}
-
-const char* android_build_id() {
-  return get_android_info().android_build_id;
-}
-
-const char* build_type() {
-  return get_android_info().build_type;
-}
-
-const char* board() {
-  return get_android_info().board;
-}
-
-const char* android_build_fp() {
-  return get_android_info().android_build_fp;
-}
-
-int sdk_int() {
-  return get_android_info().sdk_int;
-}
-
-bool is_debug_android() {
-  return get_android_info().is_debug_android;
-}
-
-const char* version_incremental() {
-  return get_android_info().version_incremental;
-}
-
-const char* hardware() {
-  return get_android_info().hardware;
-}
-
-bool is_at_least_u() {
-  return get_android_info().is_at_least_u;
-}
-
-const char* codename() {
-  return get_android_info().codename;
-}
-
-// Available only on android S+. For S-, this method returns empty string.
-const char* soc_manufacturer() {
-  return get_android_info().soc_manufacturer;
-}
-
-bool is_at_least_t() {
-  return get_android_info().is_at_least_t;
-}
-
-const char* abi_name() {
-  return get_android_info().abi_name;
-}
-
-}  // namespace base::android::android_info

src/base/android/android_info.h

@@ -1,74 +0,0 @@
-// Copyright 2025 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_ANDROID_ANDROID_INFO_H_
-#define BASE_ANDROID_ANDROID_INFO_H_
-
-#include "base/base_export.h"
-
-namespace base::android::android_info {
-
-// This enumeration maps to the values returned by AndroidInfo::sdk_int(),
-// indicating the Android release associated with a given SDK version.
-enum SdkVersion {
-  SDK_VERSION_JELLY_BEAN = 16,
-  SDK_VERSION_JELLY_BEAN_MR1 = 17,
-  SDK_VERSION_JELLY_BEAN_MR2 = 18,
-  SDK_VERSION_KITKAT = 19,
-  SDK_VERSION_KITKAT_WEAR = 20,
-  SDK_VERSION_LOLLIPOP = 21,
-  SDK_VERSION_LOLLIPOP_MR1 = 22,
-  SDK_VERSION_MARSHMALLOW = 23,
-  SDK_VERSION_NOUGAT = 24,
-  SDK_VERSION_NOUGAT_MR1 = 25,
-  SDK_VERSION_OREO = 26,
-  SDK_VERSION_O_MR1 = 27,
-  SDK_VERSION_P = 28,
-  SDK_VERSION_Q = 29,
-  SDK_VERSION_R = 30,
-  SDK_VERSION_S = 31,
-  SDK_VERSION_Sv2 = 32,
-  SDK_VERSION_T = 33,
-  SDK_VERSION_U = 34,
-  SDK_VERSION_V = 35,
-};
-
-const char* device();
-
-const char* manufacturer();
-
-const char* model();
-
-BASE_EXPORT const char* brand();
-
-const char* android_build_id();
-
-const char* build_type();
-
-const char* board();
-
-const char* android_build_fp();
-
-BASE_EXPORT int sdk_int();
-
-bool is_debug_android();
-
-const char* version_incremental();
-
-BASE_EXPORT const char* hardware();
-
-bool is_at_least_u();
-
-const char* codename();
-
-// Available only on android S+. For S-, this method returns empty string.
-const char* soc_manufacturer();
-
-bool is_at_least_t();
-
-const char* abi_name();
-
-}  // namespace base::android::android_info
-
-#endif  // BASE_ANDROID_ANDROID_INFO_H_

src/base/android/apk_info.cc

@@ -1,131 +0,0 @@
-// Copyright 2025 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/android/apk_info.h"
-
-#include <string>
-#include <variant>
-
-#include "base/android/jni_android.h"
-#include "base/android/jni_array.h"
-#include "base/android/jni_string.h"
-#include "base/android/scoped_java_ref.h"
-#include "base/strings/string_number_conversions.h"
-
-// Must come after all headers that specialize FromJniType() / ToJniType().
-#include "base/build_info_jni/ApkInfo_jni.h"
-
-namespace base::android::apk_info {
-
-namespace {
-
-struct ApkInfo {
-  // Const char* is used instead of std::strings because these values must be
-  // available even if the process is in a crash state. Sadly
-  // std::string.c_str() doesn't guarantee that memory won't be allocated when
-  // it is called.
-  const char* host_package_name;
-  const char* host_version_code;
-  const char* host_package_label;
-  const char* package_version_code;
-  const char* package_version_name;
-  const char* package_name;
-  const char* resources_version;
-  const char* installer_package_name;
-  bool is_debug_app;
-  bool targets_at_least_u;
-  int target_sdk_version;
-};
-
-std::optional<ApkInfo> holder;
-
-ApkInfo& get_apk_info() {
-  [[maybe_unused]] static auto once = [] {
-    Java_ApkInfo_nativeReadyForFields(AttachCurrentThread());
-    return std::monostate();
-  }();
-  // holder should be initialized as the java is supposed to call the native
-  // method FillFields which will initialize the fields within the holder.
-  DCHECK(holder.has_value());
-  return *holder;
-}
-
-}  // namespace
-
-static void JNI_ApkInfo_FillFields(
-    JNIEnv* env,
-    const jni_zero::JavaParamRef<jstring>& hostPackageName,
-    const jni_zero::JavaParamRef<jstring>& hostVersionCode,
-    const jni_zero::JavaParamRef<jstring>& hostPackageLabel,
-    const jni_zero::JavaParamRef<jstring>& packageVersionCode,
-    const jni_zero::JavaParamRef<jstring>& packageVersionName,
-    const jni_zero::JavaParamRef<jstring>& packageName,
-    const jni_zero::JavaParamRef<jstring>& resourcesVersion,
-    const jni_zero::JavaParamRef<jstring>& installerPackageName,
-    jboolean isDebugApp,
-    jboolean targetsAtleastU,
-    jint targetSdkVersion) {
-  DCHECK(!holder.has_value());
-  auto java_string_to_const_char =
-      [](const jni_zero::JavaParamRef<jstring>& str) {
-        return strdup(ConvertJavaStringToUTF8(str).c_str());
-      };
-  holder = ApkInfo{
-      .host_package_name = java_string_to_const_char(hostPackageName),
-      .host_version_code = java_string_to_const_char(hostVersionCode),
-      .host_package_label = java_string_to_const_char(hostPackageLabel),
-      .package_version_code = java_string_to_const_char(packageVersionCode),
-      .package_version_name = java_string_to_const_char(packageVersionName),
-      .package_name = java_string_to_const_char(packageName),
-      .resources_version = java_string_to_const_char(resourcesVersion),
-      .installer_package_name = java_string_to_const_char(installerPackageName),
-      .is_debug_app = static_cast<bool>(isDebugApp),
-      .targets_at_least_u = static_cast<bool>(targetsAtleastU),
-      .target_sdk_version = targetSdkVersion};
-}
-
-const char* host_package_name() {
-  return get_apk_info().host_package_name;
-}
-
-const char* host_version_code() {
-  return get_apk_info().host_version_code;
-}
-
-const char* host_package_label() {
-  return get_apk_info().host_package_label;
-}
-
-const char* package_version_code() {
-  return get_apk_info().package_version_code;
-}
-
-const char* package_version_name() {
-  return get_apk_info().package_version_name;
-}
-
-const char* package_name() {
-  return get_apk_info().package_name;
-}
-
-const char* resources_version() {
-  return get_apk_info().resources_version;
-}
-
-const char* installer_package_name() {
-  return get_apk_info().installer_package_name;
-}
-
-bool is_debug_app() {
-  return get_apk_info().is_debug_app;
-}
-
-int target_sdk_version() {
-  return get_apk_info().target_sdk_version;
-}
-
-bool targets_at_least_u() {
-  return get_apk_info().targets_at_least_u;
-}
-}  // namespace base::android::apk_info

src/base/android/apk_info.h

@@ -1,43 +0,0 @@
-// Copyright 2025 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_ANDROID_APK_INFO_H_
-#define BASE_ANDROID_APK_INFO_H_
-
-namespace base::android::apk_info {
-// The package name of the host app which has loaded WebView, retrieved from
-// the application context. In the context of the SDK Runtime, the package
-// name of the app that owns this particular instance of the SDK Runtime will
-// also be included. e.g.
-// com.google.android.sdksandbox:com:com.example.myappwithads
-const char* host_package_name();
-
-// The application name (e.g. "Chrome"). For WebView, this is name of the
-// embedding app. In the context of the SDK Runtime, this is the name of the
-// app that owns this particular instance of the SDK Runtime.
-const char* host_version_code();
-
-// By default: same as versionCode. For WebView: versionCode of the embedding
-// app. In the context of the SDK Runtime, this is the versionCode of the app
-// that owns this particular instance of the SDK Runtime.
-const char* host_package_label();
-
-const char* package_version_code();
-
-const char* package_version_name();
-
-const char* package_name();
-
-const char* resources_version();
-
-const char* installer_package_name();
-
-bool is_debug_app();
-
-int target_sdk_version();
-
-bool targets_at_least_u();
-
-}  // namespace base::android::apk_info
-#endif  // BASE_ANDROID_APK_INFO_H_

src/base/android/build_info.cc

@@ -6,9 +6,6 @@
 
 #include <string>
 
-#include "base/android/android_info.h"
-#include "base/android/apk_info.h"
-#include "base/android/device_info.h"
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
@@ -19,13 +16,35 @@
 #include "base/strings/string_number_conversions.h"
 
 // Must come after all headers that specialize FromJniType() / ToJniType().
-#include "base/build_info_jni/BuildInfo_jni.h"
+#include "base/base_jni/BuildInfo_jni.h"
 
 namespace base {
 namespace android {
 
+namespace {
+
+// We are leaking these strings.
+const char* StrDupParam(const std::vector<std::string>& params, size_t index) {
+  return strdup(params[index].c_str());
+}
+
+int GetIntParam(const std::vector<std::string>& params, size_t index) {
+  int ret = 0;
+  bool success = StringToInt(params[index], &ret);
+  DCHECK(success);
+  return ret;
+}
+
+}  // namespace
+
 struct BuildInfoSingletonTraits {
-  static BuildInfo* New() { return new BuildInfo(); }
+  static BuildInfo* New() {
+    JNIEnv* env = AttachCurrentThread();
+    ScopedJavaLocalRef<jobjectArray> params_objs = Java_BuildInfo_getAll(env);
+    std::vector<std::string> params;
+    AppendJavaStringArrayToStringVector(env, params_objs, &params);
+    return new BuildInfo(params);
+  }
 
   static void Delete(BuildInfo* x) {
     // We're leaking this type, see kRegisterAtExit.
@@ -38,50 +57,51 @@ struct BuildInfoSingletonTraits {
 #endif
 };
 
-BuildInfo::BuildInfo()
-    : brand_(android_info::brand()),
-      device_(android_info::device()),
-      android_build_id_(android_info::android_build_id()),
-      manufacturer_(android_info::manufacturer()),
-      model_(android_info::model()),
-      sdk_int_(android_info::sdk_int()),
-      build_type_(android_info::build_type()),
-      board_(android_info::board()),
-      host_package_name_(apk_info::host_package_name()),
-      host_version_code_(apk_info::host_version_code()),
-      host_package_label_(apk_info::host_package_label()),
-      package_name_(apk_info::package_name()),
-      package_version_code_(apk_info::package_version_code()),
-      package_version_name_(apk_info::package_version_name()),
-      android_build_fp_(android_info::android_build_fp()),
-      installer_package_name_(apk_info::installer_package_name()),
-      abi_name_(android_info::abi_name()),
-      resources_version_(apk_info::resources_version()),
-      target_sdk_version_(apk_info::target_sdk_version()),
-      is_debug_android_(android_info::is_debug_android()),
-      is_tv_(device_info::is_tv()),
-      version_incremental_(android_info::version_incremental()),
-      hardware_(android_info::hardware()),
-      is_at_least_t_(android_info::is_at_least_t()),
-      is_automotive_(device_info::is_automotive()),
-      is_at_least_u_(android_info::is_at_least_u()),
-      targets_at_least_u_(apk_info::targets_at_least_u()),
-      codename_(android_info::codename()),
-      vulkan_deqp_level_(device_info::vulkan_deqp_level()),
-      is_foldable_(device_info::is_foldable()),
-      soc_manufacturer_(android_info::soc_manufacturer()),
-      is_debug_app_(apk_info::is_debug_app()),
-      is_desktop_(device_info::is_desktop()) {}
+BuildInfo::BuildInfo(const std::vector<std::string>& params)
+    : brand_(StrDupParam(params, 0)),
+      device_(StrDupParam(params, 1)),
+      android_build_id_(StrDupParam(params, 2)),
+      manufacturer_(StrDupParam(params, 3)),
+      model_(StrDupParam(params, 4)),
+      sdk_int_(GetIntParam(params, 5)),
+      build_type_(StrDupParam(params, 6)),
+      board_(StrDupParam(params, 7)),
+      host_package_name_(StrDupParam(params, 8)),
+      host_version_code_(StrDupParam(params, 9)),
+      host_package_label_(StrDupParam(params, 10)),
+      package_name_(StrDupParam(params, 11)),
+      package_version_code_(StrDupParam(params, 12)),
+      package_version_name_(StrDupParam(params, 13)),
+      android_build_fp_(StrDupParam(params, 14)),
+      gms_version_code_(StrDupParam(params, 15)),
+      installer_package_name_(StrDupParam(params, 16)),
+      abi_name_(StrDupParam(params, 17)),
+      custom_themes_(StrDupParam(params, 18)),
+      resources_version_(StrDupParam(params, 19)),
+      target_sdk_version_(GetIntParam(params, 20)),
+      is_debug_android_(GetIntParam(params, 21)),
+      is_tv_(GetIntParam(params, 22)),
+      version_incremental_(StrDupParam(params, 23)),
+      hardware_(StrDupParam(params, 24)),
+      is_at_least_t_(GetIntParam(params, 25)),
+      is_automotive_(GetIntParam(params, 26)),
+      is_at_least_u_(GetIntParam(params, 27)),
+      targets_at_least_u_(GetIntParam(params, 28)),
+      codename_(StrDupParam(params, 29)),
+      vulkan_deqp_level_(GetIntParam(params, 30)),
+      is_foldable_(GetIntParam(params, 31)),
+      soc_manufacturer_(StrDupParam(params, 32)),
+      is_debug_app_(GetIntParam(params, 33)),
+      is_desktop_(GetIntParam(params, 34)) {}
 
 BuildInfo::~BuildInfo() = default;
 
-const char* BuildInfo::gms_version_code() const {
-  return device_info::gms_version_code();
-}
-
 void BuildInfo::set_gms_version_code_for_test(
     const std::string& gms_version_code) {
-  device_info::set_gms_version_code_for_test(gms_version_code);
+  // This leaks the string, just like production code.
+  gms_version_code_ = strdup(gms_version_code.c_str());
+  Java_BuildInfo_setGmsVersionCodeForTest(AttachCurrentThread(),
+                                          gms_version_code);
 }
 
 std::string BuildInfo::host_signing_cert_sha256() {

src/base/android/build_info.h

@@ -10,42 +10,36 @@
 #include <string>
 #include <vector>
 
-#include "base/android/android_info.h"
 #include "base/base_export.h"
 #include "base/memory/singleton.h"
 
 namespace base::android {
 
-// DEPRECATED: Please use android_info::SdkVersion.
-//
 // This enumeration maps to the values returned by BuildInfo::sdk_int(),
 // indicating the Android release associated with a given SDK version.
 enum SdkVersion {
-  SDK_VERSION_JELLY_BEAN = android_info::SDK_VERSION_JELLY_BEAN,
-  SDK_VERSION_JELLY_BEAN_MR1 = android_info::SDK_VERSION_JELLY_BEAN_MR1,
-  SDK_VERSION_JELLY_BEAN_MR2 = android_info::SDK_VERSION_JELLY_BEAN_MR2,
-  SDK_VERSION_KITKAT = android_info::SDK_VERSION_KITKAT,
-  SDK_VERSION_KITKAT_WEAR = android_info::SDK_VERSION_KITKAT_WEAR,
-  SDK_VERSION_LOLLIPOP = android_info::SDK_VERSION_LOLLIPOP,
-  SDK_VERSION_LOLLIPOP_MR1 = android_info::SDK_VERSION_LOLLIPOP_MR1,
-  SDK_VERSION_MARSHMALLOW = android_info::SDK_VERSION_MARSHMALLOW,
-  SDK_VERSION_NOUGAT = android_info::SDK_VERSION_NOUGAT,
-  SDK_VERSION_NOUGAT_MR1 = android_info::SDK_VERSION_NOUGAT_MR1,
-  SDK_VERSION_OREO = android_info::SDK_VERSION_OREO,
-  SDK_VERSION_O_MR1 = android_info::SDK_VERSION_O_MR1,
-  SDK_VERSION_P = android_info::SDK_VERSION_P,
-  SDK_VERSION_Q = android_info::SDK_VERSION_Q,
-  SDK_VERSION_R = android_info::SDK_VERSION_R,
-  SDK_VERSION_S = android_info::SDK_VERSION_S,
-  SDK_VERSION_Sv2 = android_info::SDK_VERSION_Sv2,
-  SDK_VERSION_T = android_info::SDK_VERSION_T,
-  SDK_VERSION_U = android_info::SDK_VERSION_U,
-  SDK_VERSION_V = android_info::SDK_VERSION_V,
+  SDK_VERSION_JELLY_BEAN = 16,
+  SDK_VERSION_JELLY_BEAN_MR1 = 17,
+  SDK_VERSION_JELLY_BEAN_MR2 = 18,
+  SDK_VERSION_KITKAT = 19,
+  SDK_VERSION_KITKAT_WEAR = 20,
+  SDK_VERSION_LOLLIPOP = 21,
+  SDK_VERSION_LOLLIPOP_MR1 = 22,
+  SDK_VERSION_MARSHMALLOW = 23,
+  SDK_VERSION_NOUGAT = 24,
+  SDK_VERSION_NOUGAT_MR1 = 25,
+  SDK_VERSION_OREO = 26,
+  SDK_VERSION_O_MR1 = 27,
+  SDK_VERSION_P = 28,
+  SDK_VERSION_Q = 29,
+  SDK_VERSION_R = 30,
+  SDK_VERSION_S = 31,
+  SDK_VERSION_Sv2 = 32,
+  SDK_VERSION_T = 33,
+  SDK_VERSION_U = 34,
+  SDK_VERSION_V = 35,
 };
 
-// DEPRECATED: Use AndroidInfo, DeviceInfo or ApkInfo instead.
-// These are more efficient because they only retrieve the data being queried.
-//
 // BuildInfo is a singleton class that stores android build and device
 // information. It will be called from Android specific code and gets used
 // primarily in crash reporting.
@@ -78,7 +72,7 @@ class BASE_EXPORT BuildInfo {
 
   const char* android_build_fp() const { return android_build_fp_; }
 
-  const char* gms_version_code() const;
+  const char* gms_version_code() const { return gms_version_code_; }
 
   void set_gms_version_code_for_test(const std::string& gms_version_code);
 
@@ -109,6 +103,8 @@ class BASE_EXPORT BuildInfo {
 
   const char* package_name() const { return package_name_; }
 
+  const char* custom_themes() const { return custom_themes_; }
+
   const char* resources_version() const { return resources_version_; }
 
   const char* build_type() const { return build_type_; }
@@ -162,7 +158,7 @@ class BASE_EXPORT BuildInfo {
  private:
   friend struct BuildInfoSingletonTraits;
 
-  explicit BuildInfo();
+  explicit BuildInfo(const std::vector<std::string>& params);
 
   // Const char* is used instead of std::strings because these values must be
   // available even if the process is in a crash state. Sadly
@@ -183,8 +179,11 @@ class BASE_EXPORT BuildInfo {
   const char* const package_version_code_;
   const char* const package_version_name_;
   const char* const android_build_fp_;
+  // Can be overridden in tests.
+  const char* gms_version_code_ = nullptr;
   const char* const installer_package_name_;
   const char* const abi_name_;
+  const char* const custom_themes_;
   const char* const resources_version_;
   // Not needed by breakpad.
   const int target_sdk_version_;

src/base/android/build_info_stub.cc

@@ -22,7 +22,7 @@ namespace base {
 namespace android {
 
 struct BuildInfoSingletonTraits {
-  static BuildInfo* New() { return new BuildInfo(); }
+  static BuildInfo* New() { return new BuildInfo({}); }
 
   static void Delete(BuildInfo* x) {
     // We're leaking this type, see kRegisterAtExit.
@@ -32,7 +32,7 @@ struct BuildInfoSingletonTraits {
   static const bool kRegisterAtExit = false;
 };
 
-BuildInfo::BuildInfo()
+BuildInfo::BuildInfo(const std::vector<std::string>& params)
     : brand_(""),
       device_(""),
       android_build_id_(""),
@@ -48,8 +48,10 @@ BuildInfo::BuildInfo()
       package_version_code_(""),
       package_version_name_(""),
       android_build_fp_(""),
+      gms_version_code_(""),
       installer_package_name_(""),
       abi_name_(""),
+      custom_themes_(""),
       resources_version_(""),
       target_sdk_version_(0),
       is_debug_android_(false),

src/base/android/callback_android.cc

@@ -10,9 +10,13 @@
 #include "base/android/scoped_java_ref.h"
 #include "base/time/time.h"
 #include "base/types/optional_ref.h"
+#include "build/robolectric_buildflags.h"
 
-// Must come after all headers that specialize FromJniType() / ToJniType().
+#if BUILDFLAG(IS_ROBOLECTRIC)
+#include "base/base_robolectric_jni/Callback_jni.h"  // nogncheck
+#else
 #include "base/callback_jni/Callback_jni.h"
+#endif
 
 namespace base {
 namespace android {

src/base/android/command_line_android.cc

@@ -5,9 +5,14 @@
 #include "base/command_line.h"
 
 #include "base/android/jni_string.h"
+#include "build/robolectric_buildflags.h"
 
 // Must come after all headers that specialize FromJniType() / ToJniType().
+#if BUILDFLAG(IS_ROBOLECTRIC)
+#include "base/base_robolectric_jni/CommandLine_jni.h"  // nogncheck
+#else
 #include "base/command_line_jni/CommandLine_jni.h"
+#endif
 
 using base::CommandLine;
 using base::android::JavaParamRef;

src/base/android/device_info.cc

@@ -1,101 +0,0 @@
-// Copyright 2025 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/android/device_info.h"
-
-#include <string>
-
-#include "base/android/jni_android.h"
-#include "base/android/jni_array.h"
-#include "base/android/jni_string.h"
-#include "base/android/scoped_java_ref.h"
-#include "base/strings/string_number_conversions.h"
-
-// Must come after all headers that specialize FromJniType() / ToJniType().
-#include "base/build_info_jni/DeviceInfo_jni.h"
-#include "base/synchronization/lock.h"
-
-namespace base::android::device_info {
-namespace {
-struct DeviceInfo {
-  // Const char* is used instead of std::strings because these values must be
-  // available even if the process is in a crash state. Sadly
-  // std::string.c_str() doesn't guarantee that memory won't be allocated when
-  // it is called.
-  const char* gms_version_code;
-  bool is_tv;
-  bool is_automotive;
-  bool is_foldable;
-  bool is_desktop;
-  // Available only on Android T+.
-  int32_t vulkan_deqp_level;
-};
-
-std::optional<DeviceInfo> holder;
-
-DeviceInfo& get_device_info() {
-  [[maybe_unused]] static auto once = [] {
-    Java_DeviceInfo_nativeReadyForFields(AttachCurrentThread());
-    return std::monostate();
-  }();
-  // holder should be initialized as the java is supposed to call the native
-  // method FillFields which will initialize the fields within the holder.
-  DCHECK(holder.has_value());
-  return *holder;
-}
-
-}  // namespace
-
-static void JNI_DeviceInfo_FillFields(
-    JNIEnv* env,
-    const jni_zero::JavaParamRef<jstring>& gmsVersionCode,
-    jboolean isTV,
-    jboolean isAutomotive,
-    jboolean isFoldable,
-    jboolean isDesktop,
-    jint vulkanDeqpLevel) {
-  DCHECK(!holder.has_value());
-  auto java_string_to_const_char =
-      [](const jni_zero::JavaParamRef<jstring>& str) {
-        return strdup(ConvertJavaStringToUTF8(str).c_str());
-      };
-  holder =
-      DeviceInfo{.gms_version_code = java_string_to_const_char(gmsVersionCode),
-                 .is_tv = static_cast<bool>(isTV),
-                 .is_automotive = static_cast<bool>(isAutomotive),
-                 .is_foldable = static_cast<bool>(isFoldable),
-                 .is_desktop = static_cast<bool>(isDesktop),
-                 .vulkan_deqp_level = vulkanDeqpLevel};
-}
-
-const char* gms_version_code() {
-  return get_device_info().gms_version_code;
-}
-
-void set_gms_version_code_for_test(const std::string& gms_version_code) {
-  get_device_info().gms_version_code = strdup(gms_version_code.c_str());
-  Java_DeviceInfo_setGmsVersionCodeForTest(AttachCurrentThread(),
-                                           gms_version_code);
-}
-
-bool is_tv() {
-  return get_device_info().is_tv;
-}
-bool is_automotive() {
-  return get_device_info().is_automotive;
-}
-bool is_foldable() {
-  return get_device_info().is_foldable;
-}
-
-bool is_desktop() {
-  return get_device_info().is_desktop;
-}
-
-// Available only on Android T+.
-int32_t vulkan_deqp_level() {
-  return get_device_info().vulkan_deqp_level;
-}
-
-}  // namespace base::android::device_info

src/base/android/device_info.h

@@ -1,24 +0,0 @@
-// Copyright 2025 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_ANDROID_DEVICE_INFO_H_
-#define BASE_ANDROID_DEVICE_INFO_H_
-
-#include <string>
-
-namespace base::android::device_info {
-const char* gms_version_code();
-
-void set_gms_version_code_for_test(const std::string& gms_version_code);
-
-bool is_tv();
-bool is_automotive();
-bool is_foldable();
-bool is_desktop();
-// Available only on Android T+.
-int32_t vulkan_deqp_level();
-
-}  // namespace base::android::device_info
-
-#endif  // BASE_ANDROID_DEVICE_INFO_H_

src/base/android/early_trace_event_binding.cc

@@ -28,8 +28,8 @@ static void JNI_EarlyTraceEvent_RecordEarlyBeginEvent(JNIEnv* env,
       TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED(internal::kJavaTraceCategory);
   trace_event_internal::AddTraceEventWithThreadIdAndTimestamps(
       TRACE_EVENT_PHASE_BEGIN, category_group_enabled, name.c_str(),
-      /*scope=*/nullptr, trace_event_internal::kNoId,
-      PlatformThreadId(thread_id), TimeTicks::FromJavaNanoTime(time_ns),
+      /*scope=*/nullptr, trace_event_internal::kNoId, thread_id,
+      TimeTicks::FromJavaNanoTime(time_ns),
       ThreadTicks() + Milliseconds(thread_time_ms),
       TRACE_EVENT_FLAG_JAVA_STRING_LITERALS | TRACE_EVENT_FLAG_COPY);
 #endif  // BUILDFLAG(ENABLE_BASE_TRACING)
@@ -45,8 +45,8 @@ static void JNI_EarlyTraceEvent_RecordEarlyEndEvent(JNIEnv* env,
       TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED(internal::kJavaTraceCategory);
   trace_event_internal::AddTraceEventWithThreadIdAndTimestamps(
       TRACE_EVENT_PHASE_END, category_group_enabled, name.c_str(),
-      /*scope=*/nullptr, trace_event_internal::kNoId,
-      PlatformThreadId(thread_id), TimeTicks::FromJavaNanoTime(time_ns),
+      /*scope=*/nullptr, trace_event_internal::kNoId, thread_id,
+      TimeTicks::FromJavaNanoTime(time_ns),
       ThreadTicks() + Milliseconds(thread_time_ms),
       TRACE_EVENT_FLAG_JAVA_STRING_LITERALS | TRACE_EVENT_FLAG_COPY);
 #endif  // BUILDFLAG(ENABLE_BASE_TRACING)
@@ -64,8 +64,8 @@ static void JNI_EarlyTraceEvent_RecordEarlyToplevelBeginEvent(
           internal::kToplevelTraceCategory);
   trace_event_internal::AddTraceEventWithThreadIdAndTimestamps(
       TRACE_EVENT_PHASE_BEGIN, category_group_enabled, name.c_str(),
-      /*scope=*/nullptr, trace_event_internal::kNoId,
-      PlatformThreadId(thread_id), TimeTicks::FromJavaNanoTime(time_ns),
+      /*scope=*/nullptr, trace_event_internal::kNoId, thread_id,
+      TimeTicks::FromJavaNanoTime(time_ns),
       ThreadTicks() + Milliseconds(thread_time_ms),
       TRACE_EVENT_FLAG_JAVA_STRING_LITERALS | TRACE_EVENT_FLAG_COPY);
 #endif  // BUILDFLAG(ENABLE_BASE_TRACING)
@@ -83,8 +83,8 @@ static void JNI_EarlyTraceEvent_RecordEarlyToplevelEndEvent(
           internal::kToplevelTraceCategory);
   trace_event_internal::AddTraceEventWithThreadIdAndTimestamps(
       TRACE_EVENT_PHASE_END, category_group_enabled, name.c_str(),
-      /*scope=*/nullptr, trace_event_internal::kNoId,
-      PlatformThreadId(thread_id), TimeTicks::FromJavaNanoTime(time_ns),
+      /*scope=*/nullptr, trace_event_internal::kNoId, thread_id,
+      TimeTicks::FromJavaNanoTime(time_ns),
       ThreadTicks() + Milliseconds(thread_time_ms),
       TRACE_EVENT_FLAG_JAVA_STRING_LITERALS | TRACE_EVENT_FLAG_COPY);
 #endif  // BUILDFLAG(ENABLE_BASE_TRACING)
@@ -109,7 +109,7 @@ static void JNI_EarlyTraceEvent_RecordEarlyAsyncEndEvent(JNIEnv* env,
                   perfetto::Track(static_cast<uint64_t>(id)));
 }
 
-bool GetBackgroundStartupTracingFlagFromJava() {
+bool GetBackgroundStartupTracingFlag() {
   JNIEnv* env = jni_zero::AttachCurrentThread();
   return base::android::Java_EarlyTraceEvent_getBackgroundStartupTracingFlag(
       env);

src/base/android/early_trace_event_binding.h

@@ -12,7 +12,7 @@ namespace android {
 
 // Returns true if background startup tracing flag was set on the previous
 // startup.
-BASE_EXPORT bool GetBackgroundStartupTracingFlagFromJava();
+BASE_EXPORT bool GetBackgroundStartupTracingFlag();
 
 // Sets a flag to chrome application preferences to enable startup tracing next
 // time the app is started.

src/base/android/field_trial_list.cc

@@ -73,8 +73,6 @@ static std::string JNI_FieldTrialList_GetVariationParameter(
 // friend the JNI function and is, in turn, friended by
 // FieldTrialListIncludingLowAnonymity which allows for the private
 // GetActiveFieldTrialGroups() to be reached.
-static void JNI_FieldTrialList_LogActiveTrials(JNIEnv* env);
-
 class AndroidFieldTrialListLogActiveTrialsFriendHelper {
  private:
   friend void ::JNI_FieldTrialList_LogActiveTrials(JNIEnv* env);
@@ -112,5 +110,3 @@ static jboolean JNI_FieldTrialList_CreateFieldTrial(JNIEnv* env,
   return base::FieldTrialList::CreateFieldTrial(trial_name, group_name) !=
          nullptr;
 }
-
-DEFINE_JNI_FOR_FieldTrialList()

src/base/android/int_string_callback.cc

@@ -13,7 +13,7 @@
 #include "base/android/jni_string.h"
 
 // Must come after all headers that specialize FromJniType() / ToJniType().
-#include "base/base_minimal_jni/IntStringCallback_jni.h"
+#include "base/base_jni/IntStringCallback_jni.h"
 
 namespace base {
 namespace android {
@@ -27,5 +27,3 @@ void RunIntStringCallbackAndroid(const JavaRef<jobject>& callback,
 
 }  // namespace android
 }  // namespace base
-
-DEFINE_JNI_FOR_IntStringCallback()

src/base/android/java_exception_reporter.cc

@@ -11,10 +11,16 @@
 #include "base/functional/callback.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
+#include "build/robolectric_buildflags.h"
 
 // Must come after all headers that specialize FromJniType() / ToJniType().
-#include "base/base_minimal_jni/JavaExceptionReporter_jni.h"
+#if BUILDFLAG(IS_ROBOLECTRIC)
+#include "base/base_robolectric_jni/JavaExceptionReporter_jni.h"  // nogncheck
+#else
+#include "base/base_jni/JavaExceptionReporter_jni.h"
+#endif
 
+using jni_zero::JavaParamRef;
 using jni_zero::JavaRef;
 
 namespace base {
@@ -77,7 +83,7 @@ void SetJavaException(const char* exception) {
 void JNI_JavaExceptionReporter_ReportJavaException(
     JNIEnv* env,
     jboolean crash_after_report,
-    const JavaRef<jthrowable>& e) {
+    const JavaParamRef<jthrowable>& e) {
   std::string exception_info = base::android::GetJavaExceptionInfo(env, e);
   bool should_report_exception = g_java_exception_filter.Get().Run(e);
   if (should_report_exception) {
@@ -102,5 +108,3 @@ void JNI_JavaExceptionReporter_ReportJavaStackTrace(JNIEnv* env,
 
 }  // namespace android
 }  // namespace base
-
-DEFINE_JNI_FOR_JavaExceptionReporter()

src/base/android/jni_android.cc

@@ -19,8 +19,11 @@
 #include "build/robolectric_buildflags.h"
 #include "third_party/jni_zero/jni_zero.h"
 
-// Must come after all headers that specialize FromJniType() / ToJniType().
-#include "base/base_minimal_jni/JniAndroid_jni.h"
+#if BUILDFLAG(IS_ROBOLECTRIC)
+#include "base/base_robolectric_jni/JniAndroid_jni.h"  // nogncheck
+#else
+#include "base/base_jni/JniAndroid_jni.h"
+#endif
 
 namespace base {
 namespace android {
@@ -265,5 +268,3 @@ std::string GetJavaStackTraceIfPresent() {
 
 }  // namespace android
 }  // namespace base
-
-DEFINE_JNI_FOR_JniAndroid()

src/base/android/jni_callback.cc

@@ -5,9 +5,9 @@
 #include "base/android/jni_callback.h"
 
 // Must come after all headers that specialize FromJniType() / ToJniType().
-#include "base/base_minimal_jni/JniCallbackUtils_jni.h"
-#include "base/base_minimal_jni/JniOnceCallback_jni.h"
-#include "base/base_minimal_jni/JniRepeatingCallback_jni.h"
+#include "base/base_jni/JniCallbackUtils_jni.h"
+#include "base/base_jni/JniOnceCallback_jni.h"
+#include "base/base_jni/JniRepeatingCallback_jni.h"
 
 namespace base::android {
 
@@ -110,7 +110,3 @@ void JNI_JniCallbackUtils_Destroy(JNIEnv* env,
 }
 
 }  // namespace base::android
-
-DEFINE_JNI_FOR_JniCallbackUtils()
-DEFINE_JNI_FOR_JniOnceCallback()
-DEFINE_JNI_FOR_JniRepeatingCallback()

src/base/android/jni_utils.cc

@@ -7,29 +7,26 @@
 #include "base/android/jni_string.h"
 #include "base/android/scoped_java_ref.h"
 #include "base/containers/flat_map.h"
-#include "base/lazy_instance.h"
 #include "base/no_destructor.h"
 #include "base/synchronization/lock.h"
+#include "build/robolectric_buildflags.h"
 
-// Must come after all headers that specialize FromJniType() / ToJniType().
-#include "base/base_minimal_jni/JNIUtils_jni.h"
+#if BUILDFLAG(IS_ROBOLECTRIC)
+#include "base/base_robolectric_jni/JNIUtils_jni.h"  // nogncheck
+#else
+#include "base/base_jni/JNIUtils_jni.h"
+#endif
 
 namespace base {
 namespace android {
 
-namespace {
-struct LockAndMap {
-  base::Lock lock;
-  base::flat_map<const char*, ScopedJavaGlobalRef<jobject>> map;
-};
-LockAndMap* GetLockAndMap() {
-  static base::NoDestructor<LockAndMap> lock_and_map;
-  return lock_and_map.get();
-}
-}  // namespace
-
 jobject GetSplitClassLoader(JNIEnv* env, const char* split_name) {
-  LockAndMap* lock_and_map = GetLockAndMap();
+  struct LockAndMap {
+    base::Lock lock;
+    base::flat_map<const char*, ScopedJavaGlobalRef<jobject>> map;
+  };
+  static base::NoDestructor<LockAndMap> lock_and_map;
+
   base::AutoLock guard(lock_and_map->lock);
   auto it = lock_and_map->map.find(split_name);
   if (it != lock_and_map->map.end()) {
@@ -37,7 +34,7 @@ jobject GetSplitClassLoader(JNIEnv* env, const char* split_name) {
   }
 
   ScopedJavaGlobalRef<jobject> class_loader(
-      env, Java_JNIUtils_getSplitClassLoader(env, split_name));
+      Java_JNIUtils_getSplitClassLoader(env, split_name));
   jobject class_loader_obj = class_loader.obj();
   lock_and_map->map.insert({split_name, std::move(class_loader)});
   return class_loader_obj;
@@ -45,5 +42,3 @@ jobject GetSplitClassLoader(JNIEnv* env, const char* split_name) {
 
 }  // namespace android
 }  // namespace base
-
-DEFINE_JNI_FOR_JNIUtils()

src/base/android/library_loader/library_loader_hooks.cc

@@ -16,9 +16,13 @@
 #include "base/metrics/histogram_functions.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/system/sys_info.h"
+#include "build/robolectric_buildflags.h"
 
-// Must come after all headers that specialize FromJniType() / ToJniType().
+#if BUILDFLAG(IS_ROBOLECTRIC)
+#include "base/base_robolectric_jni/LibraryLoader_jni.h"  // nogncheck
+#else
 #include "base/library_loader_jni/LibraryLoader_jni.h"
+#endif
 
 #if BUILDFLAG(ORDERFILE_INSTRUMENTATION)
 #include "base/android/orderfile/orderfile_instrumentation.h"

src/base/android/native_uma_recorder.cc

@@ -2,13 +2,10 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include <map>
-
 #include "base/android/callback_android.h"
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
-#include "base/containers/map_util.h"
 #include "base/format_macros.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/histogram_base.h"
@@ -17,9 +14,14 @@
 #include "base/metrics/user_metrics.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
+#include "build/robolectric_buildflags.h"
 
 // Must come after all headers that specialize FromJniType() / ToJniType().
+#if BUILDFLAG(IS_ROBOLECTRIC)
+#include "base/base_robolectric_jni/NativeUmaRecorder_jni.h"  // nogncheck
+#else
 #include "base/metrics_jni/NativeUmaRecorder_jni.h"
+#endif
 
 namespace base {
 namespace android {
@@ -27,25 +29,25 @@ namespace android {
 namespace {
 
 using HistogramsSnapshot =
-    std::map<std::string, std::unique_ptr<HistogramSamples>, std::less<>>;
+    std::map<std::string, std::unique_ptr<HistogramSamples>>;
 
 std::string HistogramConstructionParamsToString(HistogramBase* histogram) {
-  std::string_view name = histogram->histogram_name();
+  std::string params_str = histogram->histogram_name();
   switch (histogram->GetHistogramType()) {
     case HISTOGRAM:
     case LINEAR_HISTOGRAM:
     case BOOLEAN_HISTOGRAM:
     case CUSTOM_HISTOGRAM: {
       Histogram* hist = static_cast<Histogram*>(histogram);
-      return StringPrintf("%.*s/%d/%d/%" PRIuS, name.length(), name.data(),
-                          hist->declared_min(), hist->declared_max(),
-                          hist->bucket_count());
+      params_str += StringPrintf("/%d/%d/%" PRIuS, hist->declared_min(),
+                                 hist->declared_max(), hist->bucket_count());
+      break;
     }
     case SPARSE_HISTOGRAM:
     case DUMMY_HISTOGRAM:
       break;
   }
-  return std::string(name);
+  return params_str;
 }
 
 // Convert a jlong |histogram_hint| from Java to a HistogramBase* via a cast.
@@ -292,8 +294,7 @@ JNI_NativeUmaRecorder_GetHistogramSamplesForTesting(JNIEnv* env,
 jlong JNI_NativeUmaRecorder_CreateHistogramSnapshotForTesting(JNIEnv* env) {
   HistogramsSnapshot* snapshot = new HistogramsSnapshot();
   for (const auto* const histogram : StatisticsRecorder::GetHistograms()) {
-    InsertOrAssign(*snapshot, histogram->histogram_name(),
-                   histogram->SnapshotSamples());
+    (*snapshot)[histogram->histogram_name()] = histogram->SnapshotSamples();
   }
   return reinterpret_cast<intptr_t>(snapshot);
 }

src/base/android/pre_freeze_background_memory_trimmer.cc

@@ -28,7 +28,6 @@
 #include "base/task/thread_pool/thread_pool_instance.h"
 #include "base/time/time.h"
 #include "base/trace_event/base_tracing.h"
-#include "base/trace_event/named_trigger.h"  // no-presubmit-check
 
 namespace base::android {
 namespace {
@@ -74,7 +73,8 @@ std::string GetPreFreezeMetricName(std::string_view name,
 
 std::string GetSelfCompactionMetricName(std::string_view name,
                                         std::string_view suffix) {
-  return StrCat({"Memory.SelfCompact2.Renderer.", name, ".", suffix});
+  const char* process_type = GetProcessType();
+  return StrCat({"Memory.SelfCompact2.", process_type, ".", name, ".", suffix});
 }
 
 class PrivateMemoryFootprintMetric
@@ -221,7 +221,7 @@ void PreFreezeBackgroundMemoryTrimmer::RecordMetrics() {
   // determine the current process, which is used for the names of metrics
   // below.
   CHECK(base::CommandLine::InitializedForCurrentProcess());
-  base::AutoLock locker(lock());
+  base::AutoLock locker(lock_);
   if (metrics_.size() != values_before_.size()) {
     UmaHistogramEnumeration("Memory.PreFreeze2.RecordMetricsFailureType",
                             MetricsFailure::kSizeMismatch);
@@ -306,7 +306,7 @@ void PreFreezeBackgroundMemoryTrimmer::CompactionMetric::
     return;
   }
 
-  if (!ShouldContinueSelfCompaction(self_compaction_triggered_at_)) {
+  if (!ShouldContinueSelfCompaction(started_at_)) {
     return;
   }
 
@@ -329,7 +329,7 @@ void PreFreezeBackgroundMemoryTrimmer::CompactionMetric::
 
 void PreFreezeBackgroundMemoryTrimmer::CompactionMetric::RecordSmapsRollup(
     std::optional<debug::SmapsRollup>* target) {
-  if (!ShouldContinueSelfCompaction(self_compaction_triggered_at_)) {
+  if (!ShouldContinueSelfCompaction(started_at_)) {
     return;
   }
 
@@ -402,7 +402,7 @@ void PreFreezeBackgroundMemoryTrimmer::PostDelayedBackgroundTaskModern(
     return;
   }
 
-  base::AutoLock locker(lock());
+  base::AutoLock locker(lock_);
   PostDelayedBackgroundTaskModernHelper(std::move(task_runner), from_here,
                                         std::move(task), delay);
 }
@@ -423,7 +423,7 @@ PreFreezeBackgroundMemoryTrimmer::PostDelayedBackgroundTaskModernHelper(
 // static
 void PreFreezeBackgroundMemoryTrimmer::RegisterMemoryMetric(
     const PreFreezeMetric* metric) {
-  base::AutoLock locker(lock());
+  base::AutoLock locker(Instance().lock_);
   Instance().RegisterMemoryMetricInternal(metric);
 }
 
@@ -441,7 +441,7 @@ void PreFreezeBackgroundMemoryTrimmer::RegisterMemoryMetricInternal(
 // static
 void PreFreezeBackgroundMemoryTrimmer::UnregisterMemoryMetric(
     const PreFreezeMetric* metric) {
-  base::AutoLock locker(lock());
+  base::AutoLock locker(Instance().lock_);
   Instance().UnregisterMemoryMetricInternal(metric);
 }
 
@@ -457,12 +457,6 @@ void PreFreezeBackgroundMemoryTrimmer::UnregisterMemoryMetricInternal(
   metrics_.erase(metrics_.begin() + index);
 }
 
-void PreFreezeBackgroundMemoryTrimmer::SetOnStartSelfCompactionCallback(
-    base::RepeatingCallback<void(void)> callback) {
-  base::AutoLock locker(lock());
-  Instance().on_self_compact_callback_ = callback;
-}
-
 // static
 bool PreFreezeBackgroundMemoryTrimmer::SelfCompactionIsSupported() {
   return IsMadvisePageoutSupported();
@@ -470,10 +464,10 @@ bool PreFreezeBackgroundMemoryTrimmer::SelfCompactionIsSupported() {
 
 // static
 bool PreFreezeBackgroundMemoryTrimmer::ShouldContinueSelfCompaction(
-    base::TimeTicks self_compaction_triggered_at) {
-  base::AutoLock locker(lock());
+    base::TimeTicks self_compaction_started_at) {
+  base::AutoLock locker(Instance().lock_);
   return Instance().self_compaction_last_cancelled_ <
-         self_compaction_triggered_at;
+         self_compaction_started_at;
 }
 
 void PreFreezeBackgroundMemoryTrimmer::MaybePostSelfCompactionTask(
@@ -481,18 +475,19 @@ void PreFreezeBackgroundMemoryTrimmer::MaybePostSelfCompactionTask(
     std::vector<debug::MappedMemoryRegion> regions,
     scoped_refptr<CompactionMetric> metric,
     uint64_t max_size,
-    base::TimeTicks triggered_at) {
+    base::TimeTicks started_at) {
   TRACE_EVENT0("base", "MaybePostSelfCompactionTask");
-  if (ShouldContinueSelfCompaction(triggered_at) && !regions.empty()) {
+  if (ShouldContinueSelfCompaction(started_at) && !regions.empty()) {
     task_runner->PostDelayedTask(
         FROM_HERE,
         // |base::Unretained| is safe here because we never destroy |this|.
         base::BindOnce(&PreFreezeBackgroundMemoryTrimmer::SelfCompactionTask,
-                       base::Unretained(this), task_runner, std::move(regions),
-                       std::move(metric), max_size, triggered_at),
+                       base::Unretained(this), std::move(task_runner),
+                       std::move(regions), std::move(metric), max_size,
+                       started_at),
         GetDelayBetweenSelfCompaction());
   } else {
-    FinishSelfCompaction(std::move(metric), triggered_at);
+    FinishSelfCompaction(std::move(metric), started_at);
   }
 }
 
@@ -501,8 +496,8 @@ void PreFreezeBackgroundMemoryTrimmer::SelfCompactionTask(
     std::vector<debug::MappedMemoryRegion> regions,
     scoped_refptr<CompactionMetric> metric,
     uint64_t max_size,
-    base::TimeTicks triggered_at) {
-  if (!ShouldContinueSelfCompaction(triggered_at)) {
+    base::TimeTicks started_at) {
+  if (!ShouldContinueSelfCompaction(started_at)) {
     return;
   }
 
@@ -511,45 +506,33 @@ void PreFreezeBackgroundMemoryTrimmer::SelfCompactionTask(
   CompactMemory(&regions, max_size);
 
   MaybePostSelfCompactionTask(std::move(task_runner), std::move(regions),
-                              std::move(metric), max_size, triggered_at);
+                              std::move(metric), max_size, started_at);
 }
 
 void PreFreezeBackgroundMemoryTrimmer::StartSelfCompaction(
     scoped_refptr<base::SequencedTaskRunner> task_runner,
     std::vector<debug::MappedMemoryRegion> regions,
+    scoped_refptr<CompactionMetric> metric,
     uint64_t max_bytes,
-    base::TimeTicks triggered_at) {
-  scoped_refptr<CompactionMetric> metric =
-      MakeRefCounted<CompactionMetric>(triggered_at, base::TimeTicks::Now());
+    base::TimeTicks started_at) {
   TRACE_EVENT0("base", "StartSelfCompaction");
-  base::trace_event::EmitNamedTrigger("start-self-compaction");
   {
-    base::AutoLock locker(lock());
+    base::AutoLock locker(lock_);
     process_compacted_metadata_.emplace(
         "PreFreezeBackgroundMemoryTrimmer.ProcessCompacted",
         /*is_compacted=*/1, base::SampleMetadataScope::kProcess);
-    if (on_self_compact_callback_) {
-      on_self_compact_callback_.Run();
-    }
   }
   metric->RecordBeforeMetrics();
   MaybePostSelfCompactionTask(std::move(task_runner), std::move(regions),
-                              std::move(metric), max_bytes, triggered_at);
+                              std::move(metric), max_bytes, started_at);
 }
 
 void PreFreezeBackgroundMemoryTrimmer::FinishSelfCompaction(
     scoped_refptr<CompactionMetric> metric,
-    base::TimeTicks triggered_at) {
+    base::TimeTicks started_at) {
   TRACE_EVENT0("base", "FinishSelfCompaction");
-  {
-    base::AutoLock locker(lock());
-    self_compaction_last_finished_ = base::TimeTicks::Now();
-  }
-  if (ShouldContinueSelfCompaction(triggered_at)) {
+  if (ShouldContinueSelfCompaction(started_at)) {
     metric->RecordDelayedMetrics();
-    base::AutoLock locker(lock());
-    metric->RecordTimeMetrics(self_compaction_last_finished_,
-                              self_compaction_last_cancelled_);
   }
 }
 
@@ -562,41 +545,24 @@ PreFreezeBackgroundMemoryTrimmer::GetDelayBetweenSelfCompaction() {
 }
 
 // static
-void PreFreezeBackgroundMemoryTrimmer::MaybeCancelSelfCompaction(
-    SelfCompactCancellationReason cancellation_reason) {
-  Instance().MaybeCancelSelfCompactionInternal(cancellation_reason);
+void PreFreezeBackgroundMemoryTrimmer::MaybeCancelSelfCompaction() {
+  Instance().MaybeCancelSelfCompactionInternal();
 }
 
-void PreFreezeBackgroundMemoryTrimmer::MaybeCancelSelfCompactionInternal(
-    SelfCompactCancellationReason cancellation_reason) {
-  base::AutoLock locker(lock());
+void PreFreezeBackgroundMemoryTrimmer::MaybeCancelSelfCompactionInternal() {
+  base::AutoLock locker(lock_);
   process_compacted_metadata_.reset();
-  // Check for the last time cancelled here in order to avoid recording this
-  // metric multiple times. Also, only record this metric if a compaction is
-  // currently running.
-  if (self_compaction_last_cancelled_ < self_compaction_last_triggered_ &&
-      self_compaction_last_finished_ < self_compaction_last_triggered_) {
-    UmaHistogramEnumeration("Memory.SelfCompact2.Renderer.CancellationReason2",
-                            cancellation_reason);
-  }
-  self_compaction_last_finished_ = self_compaction_last_cancelled_ =
-      base::TimeTicks::Now();
+  self_compaction_last_cancelled_ = base::TimeTicks::Now();
 }
 
 // static
-void PreFreezeBackgroundMemoryTrimmer::CompactSelf(
-    scoped_refptr<base::SequencedTaskRunner> task_runner,
-    base::TimeTicks triggered_at) {
+void PreFreezeBackgroundMemoryTrimmer::CompactSelf() {
   // MADV_PAGEOUT was only added in Linux 5.4, so do nothing in earlier
   // versions.
   if (!SelfCompactionIsSupported()) {
     return;
   }
 
-  if (!ShouldContinueSelfCompaction(triggered_at)) {
-    return;
-  }
-
   TRACE_EVENT0("base", "CompactSelf");
   std::vector<debug::MappedMemoryRegion> regions;
 
@@ -613,29 +579,28 @@ void PreFreezeBackgroundMemoryTrimmer::CompactSelf(
     }
   }
 
-  Instance().StartSelfCompaction(std::move(task_runner), std::move(regions),
-                                 MiBToBytes(kShouldFreezeSelfMaxSize.Get()),
-                                 triggered_at);
+  auto started_at = base::TimeTicks::Now();
+  Instance().StartSelfCompaction(
+      base::ThreadPool::CreateSequencedTaskRunner(
+          {base::TaskPriority::BEST_EFFORT, MayBlock()}),
+      std::move(regions), MakeRefCounted<CompactionMetric>(started_at),
+      MiBToBytes(kShouldFreezeSelfMaxSize.Get()), started_at);
 }
 
 // static
 std::optional<uint64_t> PreFreezeBackgroundMemoryTrimmer::CompactRegion(
     debug::MappedMemoryRegion region) {
 #if defined(MADV_PAGEOUT)
-  using Permission = debug::MappedMemoryRegion::Permission;
   // Skip file-backed regions
   if (region.inode != 0 || region.dev_major != 0) {
     return 0;
   }
   // Skip shared regions
-  if ((region.permissions & Permission::PRIVATE) == 0) {
+  if ((region.permissions & debug::MappedMemoryRegion::Permission::PRIVATE) ==
+      0) {
     return 0;
   }
 
-  const bool is_inaccessible =
-      (region.permissions &
-       (Permission::READ | Permission::WRITE | Permission::EXECUTE)) == 0;
-
   TRACE_EVENT1("base", __PRETTY_FUNCTION__, "size", region.end - region.start);
 
   int error = madvise(reinterpret_cast<void*>(region.start),
@@ -656,7 +621,7 @@ std::optional<uint64_t> PreFreezeBackgroundMemoryTrimmer::CompactRegion(
     return 0;
   }
 
-  return is_inaccessible ? 0 : region.end - region.start;
+  return region.end - region.start;
 #else
   return std::nullopt;
 #endif
@@ -694,23 +659,19 @@ void PreFreezeBackgroundMemoryTrimmer::PostMetricsTasksIfModern() {
 void PreFreezeBackgroundMemoryTrimmer::OnSelfFreeze() {
   TRACE_EVENT0("base", "OnSelfFreeze");
 
-  auto task_runner = base::ThreadPool::CreateSequencedTaskRunner(
-      {base::TaskPriority::BEST_EFFORT, MayBlock()});
-  Instance().OnSelfFreezeInternal(std::move(task_runner));
+  Instance().OnSelfFreezeInternal();
 }
 
-void PreFreezeBackgroundMemoryTrimmer::OnSelfFreezeInternal(
-    scoped_refptr<SequencedTaskRunner> task_runner) {
-  const auto triggered_at = base::TimeTicks::Now();
-  base::AutoLock locker(lock());
-  self_compaction_last_triggered_ = triggered_at;
+void PreFreezeBackgroundMemoryTrimmer::OnSelfFreezeInternal() {
+  base::AutoLock locker(lock_);
   if (base::FeatureList::IsEnabled(kShouldFreezeSelf)) {
     RunPreFreezeTasks();
   }
-  task_runner->PostDelayedTask(
-      FROM_HERE,
+
+  base::ThreadPool::PostDelayedTask(
+      FROM_HERE, {base::TaskPriority::BEST_EFFORT, MayBlock()},
       base::BindOnce(&PreFreezeBackgroundMemoryTrimmer::CompactSelf,
-                     base::Unretained(this), task_runner, triggered_at),
+                     base::Unretained(this)),
       base::Seconds(kShouldFreezeSelfDelayAfterPreFreezeTasks.Get()));
 }
 
@@ -719,7 +680,7 @@ void PreFreezeBackgroundMemoryTrimmer::OnPreFreeze() {
   // If we have scheduled a self compaction task, cancel it, since App Freezer
   // will handle the compaction for us, and we don't want to potentially run
   // self compaction after we have resumed.
-  MaybeCancelSelfCompaction(SelfCompactCancellationReason::kAppFreezer);
+  MaybeCancelSelfCompaction();
   Instance().OnPreFreezeInternal();
 }
 
@@ -744,13 +705,13 @@ void PreFreezeBackgroundMemoryTrimmer::RunPreFreezeTasks() {
     // (1) To avoid holding it too long while running all the background tasks.
     // (2) To prevent a deadlock if the |background_task| needs to acquire the
     //     lock (e.g. to post another task).
-    base::AutoUnlock unlocker(lock());
+    base::AutoUnlock unlocker(lock_);
     BackgroundTask::RunNow(std::move(background_task));
   }
 }
 
 void PreFreezeBackgroundMemoryTrimmer::OnPreFreezeInternal() {
-  base::AutoLock locker(lock());
+  base::AutoLock locker(lock_);
   PostMetricsTasksIfModern();
 
   if (!ShouldUseModernTrim()) {
@@ -768,13 +729,13 @@ void PreFreezeBackgroundMemoryTrimmer::UnregisterBackgroundTask(
 
 void PreFreezeBackgroundMemoryTrimmer::UnregisterBackgroundTaskInternal(
     BackgroundTask* timer) {
-  base::AutoLock locker(lock());
+  base::AutoLock locker(lock_);
   std::erase_if(background_tasks_, [&](auto& t) { return t.get() == timer; });
 }
 
 // static
 void PreFreezeBackgroundMemoryTrimmer::RegisterPrivateMemoryFootprintMetric() {
-  base::AutoLock locker(lock());
+  base::AutoLock locker(Instance().lock_);
   static base::NoDestructor<PrivateMemoryFootprintMetric> pmf_metric;
   if (!PrivateMemoryFootprintMetric::did_register_) {
     PrivateMemoryFootprintMetric::did_register_ = true;
@@ -805,41 +766,40 @@ void PreFreezeBackgroundMemoryTrimmer::SetSupportsModernTrimForTesting(
 
 // static
 void PreFreezeBackgroundMemoryTrimmer::ClearMetricsForTesting() {
-  base::AutoLock locker(lock());
+  base::AutoLock locker(Instance().lock_);
   Instance().metrics_.clear();
   PrivateMemoryFootprintMetric::did_register_ = false;
 }
 
 bool PreFreezeBackgroundMemoryTrimmer::DidRegisterTasksForTesting() const {
-  base::AutoLock locker(lock());
+  base::AutoLock locker(lock_);
   return metrics_.size() != 0;
 }
 
 size_t
 PreFreezeBackgroundMemoryTrimmer::GetNumberOfPendingBackgroundTasksForTesting()
     const {
-  base::AutoLock locker(lock());
+  base::AutoLock locker(lock_);
   return background_tasks_.size();
 }
 
 size_t PreFreezeBackgroundMemoryTrimmer::GetNumberOfKnownMetricsForTesting()
     const {
-  base::AutoLock locker(lock());
+  base::AutoLock locker(lock_);
   return metrics_.size();
 }
 
 size_t PreFreezeBackgroundMemoryTrimmer::GetNumberOfValuesBeforeForTesting()
     const {
-  base::AutoLock locker(lock());
+  base::AutoLock locker(lock_);
   return values_before_.size();
 }
 
 // static
-void PreFreezeBackgroundMemoryTrimmer::ResetSelfCompactionForTesting() {
-  base::AutoLock locker(lock());
+void PreFreezeBackgroundMemoryTrimmer::
+    ResetSelfCompactionLastCancelledForTesting() {
+  base::AutoLock locker(Instance().lock_);
   Instance().self_compaction_last_cancelled_ = base::TimeTicks::Min();
-  Instance().self_compaction_last_finished_ = base::TimeTicks::Min();
-  Instance().self_compaction_last_triggered_ = base::TimeTicks::Min();
 }
 
 // static
@@ -919,10 +879,8 @@ PreFreezeBackgroundMemoryTrimmer::PreFreezeMetric::PreFreezeMetric(
 PreFreezeBackgroundMemoryTrimmer::PreFreezeMetric::~PreFreezeMetric() = default;
 
 PreFreezeBackgroundMemoryTrimmer::CompactionMetric::CompactionMetric(
-    base::TimeTicks triggered_at,
     base::TimeTicks started_at)
-    : self_compaction_triggered_at_(triggered_at),
-      self_compaction_started_at_(started_at) {}
+    : started_at_(started_at) {}
 PreFreezeBackgroundMemoryTrimmer::CompactionMetric::~CompactionMetric() =
     default;
 
@@ -938,13 +896,4 @@ void PreFreezeBackgroundMemoryTrimmer::CompactionMetric::
   RecordSmapsRollupWithDelay(&smaps_after_60s_, base::Seconds(60));
 }
 
-void PreFreezeBackgroundMemoryTrimmer::CompactionMetric::RecordTimeMetrics(
-    base::TimeTicks last_finished,
-    base::TimeTicks last_cancelled) {
-  UmaHistogramMediumTimes("Memory.SelfCompact2.Renderer.SelfCompactionTime",
-                          last_finished - self_compaction_started_at_);
-  UmaHistogramMediumTimes("Memory.SelfCompact2.Renderer.TimeSinceLastCancel",
-                          last_finished - last_cancelled);
-}
-
 }  // namespace base::android

src/base/android/pre_freeze_background_memory_trimmer.h

@@ -35,14 +35,6 @@ BASE_EXPORT BASE_DECLARE_FEATURE(kShouldFreezeSelf);
 // be frozen.
 class BASE_EXPORT PreFreezeBackgroundMemoryTrimmer {
  public:
-  // These values are persisted to logs. Entries should not be renumbered and
-  // numeric values should never be reused.
-  enum class SelfCompactCancellationReason {
-    kAppFreezer,
-    kPageResumed,
-    kMaxValue = kPageResumed
-  };
-
   static PreFreezeBackgroundMemoryTrimmer& Instance();
   ~PreFreezeBackgroundMemoryTrimmer() = delete;
 
@@ -53,7 +45,7 @@ class BASE_EXPORT PreFreezeBackgroundMemoryTrimmer {
       scoped_refptr<base::SequencedTaskRunner> task_runner,
       const base::Location& from_here,
       OnceCallback<void(void)> task,
-      base::TimeDelta delay) LOCKS_EXCLUDED(lock()) {
+      base::TimeDelta delay) LOCKS_EXCLUDED(lock_) {
     PostDelayedBackgroundTask(
         task_runner, from_here,
         BindOnce(
@@ -68,7 +60,7 @@ class BASE_EXPORT PreFreezeBackgroundMemoryTrimmer {
       scoped_refptr<base::SequencedTaskRunner> task_runner,
       const base::Location& from_here,
       OnceCallback<void(MemoryReductionTaskContext)> task,
-      base::TimeDelta delay) LOCKS_EXCLUDED(lock());
+      base::TimeDelta delay) LOCKS_EXCLUDED(lock_);
 
   class PreFreezeMetric {
    public:
@@ -110,47 +102,38 @@ class BASE_EXPORT PreFreezeBackgroundMemoryTrimmer {
   // See "Memory.PreFreeze2.{process_type}.{name}.{suffix}" for details on the
   // exact metrics.
   static void RegisterMemoryMetric(const PreFreezeMetric* metric)
-      LOCKS_EXCLUDED(lock());
+      LOCKS_EXCLUDED(Instance().lock_);
 
   static void UnregisterMemoryMetric(const PreFreezeMetric* metric)
-      LOCKS_EXCLUDED(lock());
-
-  // The callback runs in the thread pool. The caller cannot make any thread
-  // safety assumptions for the callback execution (e.g. it could run
-  // concurrently with the thread that registered it).
-  static void SetOnStartSelfCompactionCallback(base::RepeatingClosure callback)
-      LOCKS_EXCLUDED(lock());
+      LOCKS_EXCLUDED(Instance().lock_);
 
   static bool SelfCompactionIsSupported();
 
   // Compacts the memory for the process.
-  void CompactSelf(scoped_refptr<SequencedTaskRunner> task_runner,
-                   base::TimeTicks triggered_at);
+  void CompactSelf();
 
-  // If we are currently running self compaction, cancel it. If it was running,
-  // record a metric with the reason for the cancellation.
-  static void MaybeCancelSelfCompaction(
-      SelfCompactCancellationReason cancellation_reason);
+  // If we are currently running self compaction, cancel it.
+  static void MaybeCancelSelfCompaction();
 
   static void SetSupportsModernTrimForTesting(bool is_supported);
-  static void ClearMetricsForTesting() LOCKS_EXCLUDED(lock());
+  static void ClearMetricsForTesting() LOCKS_EXCLUDED(lock_);
   size_t GetNumberOfPendingBackgroundTasksForTesting() const
-      LOCKS_EXCLUDED(lock());
-  size_t GetNumberOfKnownMetricsForTesting() const LOCKS_EXCLUDED(lock());
-  size_t GetNumberOfValuesBeforeForTesting() const LOCKS_EXCLUDED(lock());
+      LOCKS_EXCLUDED(lock_);
+  size_t GetNumberOfKnownMetricsForTesting() const LOCKS_EXCLUDED(lock_);
+  size_t GetNumberOfValuesBeforeForTesting() const LOCKS_EXCLUDED(lock_);
   bool DidRegisterTasksForTesting() const;
 
-  static void OnPreFreezeForTesting() LOCKS_EXCLUDED(lock()) { OnPreFreeze(); }
-  static void ResetSelfCompactionForTesting();
+  static void OnPreFreezeForTesting() LOCKS_EXCLUDED(lock_) { OnPreFreeze(); }
+  static void ResetSelfCompactionLastCancelledForTesting();
 
   static std::optional<uint64_t> CompactRegion(
       debug::MappedMemoryRegion region);
 
   // Called when Chrome is about to be frozen. Runs as many delayed tasks as
   // possible immediately, before we are frozen.
-  static void OnPreFreeze() LOCKS_EXCLUDED(lock());
+  static void OnPreFreeze() LOCKS_EXCLUDED(lock_);
 
-  static void OnSelfFreeze() LOCKS_EXCLUDED(lock());
+  static void OnSelfFreeze() LOCKS_EXCLUDED(lock_);
 
   static bool SupportsModernTrim();
   static bool ShouldUseModernTrim();
@@ -166,7 +149,6 @@ class BASE_EXPORT PreFreezeBackgroundMemoryTrimmer {
   friend class PreFreezeSelfCompactionTest;
   FRIEND_TEST_ALL_PREFIXES(PreFreezeSelfCompactionTest, Cancel);
   FRIEND_TEST_ALL_PREFIXES(PreFreezeSelfCompactionTest, NotCanceled);
-  FRIEND_TEST_ALL_PREFIXES(PreFreezeSelfCompactionTest, OnSelfFreezeCancel);
 
   // We use our own implementation here, based on |PostCancelableDelayedTask|,
   // rather than relying on something like |base::OneShotTimer|, since
@@ -208,30 +190,20 @@ class BASE_EXPORT PreFreezeBackgroundMemoryTrimmer {
  private:
   class CompactionMetric : public RefCountedThreadSafe<CompactionMetric> {
    public:
-    CompactionMetric(base::TimeTicks triggered_at, base::TimeTicks started_at);
+    explicit CompactionMetric(base::TimeTicks started_at);
 
     void RecordDelayedMetrics();
-    void RecordTimeMetrics(base::TimeTicks self_compaction_last_finished,
-                           base::TimeTicks self_compaction_last_cancelled);
 
     void RecordBeforeMetrics();
-    void MaybeRecordCompactionMetrics() LOCKS_EXCLUDED(lock());
+    void MaybeRecordCompactionMetrics();
 
    private:
     friend class RefCountedThreadSafe<CompactionMetric>;
     ~CompactionMetric();
-    void RecordSmapsRollup(std::optional<debug::SmapsRollup>* target)
-        LOCKS_EXCLUDED(lock());
+    void RecordSmapsRollup(std::optional<debug::SmapsRollup>* target);
     void RecordSmapsRollupWithDelay(std::optional<debug::SmapsRollup>* target,
                                     base::TimeDelta delay);
-    // When the self compaction was first triggered. There is a delay between
-    // this time and when we actually begin the compaction.
-    base::TimeTicks self_compaction_triggered_at_;
-    // When the self compaction first started. This should generally be
-    // |self_compaction_triggered_at_ +
-    // kShouldFreezeSelfDelayAfterPreFreezeTasks.Get()|, but may be longer if
-    // the task was delayed.
-    base::TimeTicks self_compaction_started_at_;
+    base::TimeTicks started_at_;
     // We use std::optional here because:
     // - We record these incrementally.
     // - We may stop recording at some point.
@@ -245,84 +217,84 @@ class BASE_EXPORT PreFreezeBackgroundMemoryTrimmer {
 
   PreFreezeBackgroundMemoryTrimmer();
 
-  static base::Lock& lock() { return Instance().lock_; }
-
   void StartSelfCompaction(scoped_refptr<base::SequencedTaskRunner> task_runner,
                            std::vector<debug::MappedMemoryRegion> regions,
+                           scoped_refptr<CompactionMetric> metric,
                            uint64_t max_size,
-                           base::TimeTicks triggered_at) LOCKS_EXCLUDED(lock());
+                           base::TimeTicks started_at);
   static base::TimeDelta GetDelayBetweenSelfCompaction();
   void MaybePostSelfCompactionTask(
       scoped_refptr<base::SequencedTaskRunner> task_runner,
       std::vector<debug::MappedMemoryRegion> regions,
       scoped_refptr<CompactionMetric> metric,
       uint64_t max_size,
-      base::TimeTicks triggered_at) LOCKS_EXCLUDED(lock());
+      base::TimeTicks started_at);
   void SelfCompactionTask(scoped_refptr<base::SequencedTaskRunner> task_runner,
                           std::vector<debug::MappedMemoryRegion> regions,
                           scoped_refptr<CompactionMetric> metric,
                           uint64_t max_size,
-                          base::TimeTicks triggered_at) LOCKS_EXCLUDED(lock());
+                          base::TimeTicks started_at);
   void FinishSelfCompaction(scoped_refptr<CompactionMetric> metric,
-                            base::TimeTicks triggered_at)
-      LOCKS_EXCLUDED(lock());
+                            base::TimeTicks started_at);
 
   static bool ShouldContinueSelfCompaction(
-      base::TimeTicks self_compaction_triggered_at) LOCKS_EXCLUDED(lock());
+      base::TimeTicks compaction_started_at) LOCKS_EXCLUDED(Instance().lock_);
 
   static std::optional<uint64_t> CompactMemory(
       std::vector<debug::MappedMemoryRegion>* regions,
       const uint64_t max_bytes);
 
   void RegisterMemoryMetricInternal(const PreFreezeMetric* metric)
-      EXCLUSIVE_LOCKS_REQUIRED(lock());
+      EXCLUSIVE_LOCKS_REQUIRED(lock_);
 
   void UnregisterMemoryMetricInternal(const PreFreezeMetric* metric)
-      EXCLUSIVE_LOCKS_REQUIRED(lock());
-  static void UnregisterBackgroundTask(BackgroundTask*) LOCKS_EXCLUDED(lock());
+      EXCLUSIVE_LOCKS_REQUIRED(lock_);
+  static void UnregisterBackgroundTask(BackgroundTask*) LOCKS_EXCLUDED(lock_);
 
-  void UnregisterBackgroundTaskInternal(BackgroundTask*) LOCKS_EXCLUDED(lock());
+  void UnregisterBackgroundTaskInternal(BackgroundTask*) LOCKS_EXCLUDED(lock_);
 
-  static void RegisterPrivateMemoryFootprintMetric() LOCKS_EXCLUDED(lock());
-  void RegisterPrivateMemoryFootprintMetricInternal() LOCKS_EXCLUDED(lock());
+  static void RegisterPrivateMemoryFootprintMetric() LOCKS_EXCLUDED(lock_);
+  void RegisterPrivateMemoryFootprintMetricInternal() LOCKS_EXCLUDED(lock_);
 
   void PostDelayedBackgroundTaskInternal(
       scoped_refptr<base::SequencedTaskRunner> task_runner,
       const base::Location& from_here,
       OnceCallback<void(MemoryReductionTaskContext)> task,
-      base::TimeDelta delay) LOCKS_EXCLUDED(lock());
+      base::TimeDelta delay) LOCKS_EXCLUDED(lock_);
   void PostDelayedBackgroundTaskModern(
       scoped_refptr<base::SequencedTaskRunner> task_runner,
       const base::Location& from_here,
       OnceCallback<void(MemoryReductionTaskContext)> task,
-      base::TimeDelta delay) LOCKS_EXCLUDED(lock());
+      base::TimeDelta delay) LOCKS_EXCLUDED(lock_);
   BackgroundTask* PostDelayedBackgroundTaskModernHelper(
       scoped_refptr<base::SequencedTaskRunner> task_runner,
       const base::Location& from_here,
       OnceCallback<void(MemoryReductionTaskContext)> task,
-      base::TimeDelta delay) EXCLUSIVE_LOCKS_REQUIRED(lock());
+      base::TimeDelta delay) EXCLUSIVE_LOCKS_REQUIRED(lock_);
 
-  void OnPreFreezeInternal() LOCKS_EXCLUDED(lock());
-  void RunPreFreezeTasks() EXCLUSIVE_LOCKS_REQUIRED(lock());
+  void OnPreFreezeInternal() LOCKS_EXCLUDED(lock_);
+  void RunPreFreezeTasks() EXCLUSIVE_LOCKS_REQUIRED(lock_);
 
-  void OnSelfFreezeInternal(scoped_refptr<SequencedTaskRunner> task_runner);
+  void OnSelfFreezeInternal();
 
-  void MaybeCancelSelfCompactionInternal(
-      SelfCompactCancellationReason cancellation_reason) LOCKS_EXCLUDED(lock());
+  void MaybeCancelSelfCompactionInternal() LOCKS_EXCLUDED(lock_);
 
-  void PostMetricsTasksIfModern() EXCLUSIVE_LOCKS_REQUIRED(lock());
-  void PostMetricsTask() EXCLUSIVE_LOCKS_REQUIRED(lock());
-  void RecordMetrics() LOCKS_EXCLUDED(lock());
+  void PostMetricsTasksIfModern() EXCLUSIVE_LOCKS_REQUIRED(lock_);
+  void PostMetricsTask() EXCLUSIVE_LOCKS_REQUIRED(lock_);
+  void RecordMetrics() LOCKS_EXCLUDED(lock_);
+
+  void RecordSmapsRollup(std::optional<debug::SmapsRollup>* target,
+                         base::TimeTicks started_at);
 
   mutable base::Lock lock_;
   std::deque<std::unique_ptr<BackgroundTask>> background_tasks_
-      GUARDED_BY(lock());
-  std::vector<const PreFreezeMetric*> metrics_ GUARDED_BY(lock());
+      GUARDED_BY(lock_);
+  std::vector<const PreFreezeMetric*> metrics_ GUARDED_BY(lock_);
   // When a metrics task is posted (see |RecordMetrics|), the values of each
   // metric before any tasks are run are saved here. The "i"th entry corresponds
   // to the "i"th entry in |metrics_|. When there is no pending metrics task,
   // |values_before_| should be empty.
-  std::vector<std::optional<uint64_t>> values_before_ GUARDED_BY(lock());
+  std::vector<std::optional<uint64_t>> values_before_ GUARDED_BY(lock_);
   // Whether or not we should continue self compaction. There are two reasons
   // why we would cancel:
   // (1) We have resumed, meaning we are likely to touch much of the process
@@ -332,18 +304,10 @@ class BASE_EXPORT PreFreezeBackgroundMemoryTrimmer {
   //     work for us. This situation should be relatively rare, because we
   //     attempt to not do self compaction if we know that we are going to
   //     frozen by App Freezer.
-  base::TimeTicks self_compaction_last_cancelled_ GUARDED_BY(lock()) =
-      base::TimeTicks::Min();
-  // When we last triggered self compaction. Used to record metrics.
-  base::TimeTicks self_compaction_last_triggered_ GUARDED_BY(lock()) =
-      base::TimeTicks::Min();
-  // When we last finished self compaction (either successfully, or from
-  // being cancelled). Used to record metrics.
-  base::TimeTicks self_compaction_last_finished_ GUARDED_BY(lock()) =
+  base::TimeTicks self_compaction_last_cancelled_ GUARDED_BY(lock_) =
       base::TimeTicks::Min();
   std::optional<base::ScopedSampleMetadata> process_compacted_metadata_
-      GUARDED_BY(lock());
-  base::RepeatingClosure on_self_compact_callback_ GUARDED_BY(lock());
+      GUARDED_BY(lock_);
   bool supports_modern_trim_;
 };
 

src/base/android/token_android.cc

@@ -4,8 +4,15 @@
 
 #include "base/android/token_android.h"
 
-#include "base/base_minimal_jni/TokenBase_jni.h"
-#include "base/base_minimal_jni/Token_jni.h"
+#include "build/robolectric_buildflags.h"
+
+#if BUILDFLAG(IS_ROBOLECTRIC)
+#include "base/base_robolectric_jni/TokenBase_jni.h"  // nogncheck
+#include "base/base_robolectric_jni/Token_jni.h"      // nogncheck
+#else
+#include "base/base_jni/TokenBase_jni.h"
+#include "base/base_jni/Token_jni.h"
+#endif
 
 namespace base::android {
 
@@ -29,5 +36,3 @@ static base::Token JNI_Token_CreateRandom(JNIEnv* env) {
 }
 
 }  // namespace base::android
-
-DEFINE_JNI_FOR_Token()

src/base/android/trace_event_binding.cc

@@ -13,6 +13,13 @@
 #include "base/metrics/histogram_macros.h"
 #include "base/trace_event/base_tracing.h"
 #include "base/tracing_buildflags.h"
+#include "build/robolectric_buildflags.h"
+
+#if BUILDFLAG(IS_ROBOLECTRIC)
+#include "base/base_robolectric_jni/TraceEvent_jni.h"  // nogncheck
+#else
+#include "base/tasks_jni/TraceEvent_jni.h"
+#endif
 
 #if BUILDFLAG(ENABLE_BASE_TRACING)
 #include "base/trace_event/trace_event_impl.h"  // no-presubmit-check
@@ -20,9 +27,6 @@
 #include "third_party/perfetto/protos/perfetto/config/chrome/chrome_config.gen.h"  // nogncheck
 #endif  // BUILDFLAG(ENABLE_BASE_TRACING)
 
-// Must come after all headers that specialize FromJniType() / ToJniType().
-#include "base/tasks_minimal_jni/TraceEvent_jni.h"
-
 namespace base {
 namespace android {
 
@@ -306,24 +310,21 @@ static void JNI_TraceEvent_WebViewStartupStage1(JNIEnv* env,
 #endif  // BUILDFLAG(ENABLE_BASE_TRACING)
 }
 
-static void JNI_TraceEvent_WebViewStartupFirstInstance(
-    JNIEnv* env,
-    jlong start_time_ms,
-    jlong duration_ms,
-    jboolean included_global_startup) {
+static void JNI_TraceEvent_WebViewStartupStage2(JNIEnv* env,
+                                                jlong start_time_ms,
+                                                jlong duration_ms,
+                                                jboolean is_cold_startup) {
 #if BUILDFLAG(ENABLE_BASE_TRACING)
   auto t = perfetto::Track::ThreadScoped(
       reinterpret_cast<void*>(trace_event::GetNextGlobalTraceId()));
-  if (included_global_startup) {
-    TRACE_EVENT_BEGIN(
-        "android_webview.timeline",
-        "WebView.Startup.CreationTime.FirstInstanceWithGlobalStartup", t,
-        TimeTicks() + Milliseconds(start_time_ms));
+  if (is_cold_startup) {
+    TRACE_EVENT_BEGIN("android_webview.timeline",
+                      "WebView.Startup.CreationTime.Stage2.ProviderInit.Cold",
+                      t, TimeTicks() + Milliseconds(start_time_ms));
   } else {
-    TRACE_EVENT_BEGIN(
-        "android_webview.timeline",
-        "WebView.Startup.CreationTime.FirstInstanceWithoutGlobalStartup", t,
-        TimeTicks() + Milliseconds(start_time_ms));
+    TRACE_EVENT_BEGIN("android_webview.timeline",
+                      "WebView.Startup.CreationTime.Stage2.ProviderInit.Warm",
+                      t, TimeTicks() + Milliseconds(start_time_ms));
   }
 
   TRACE_EVENT_END("android_webview.timeline", t,
@@ -331,20 +332,6 @@ static void JNI_TraceEvent_WebViewStartupFirstInstance(
 #endif  // BUILDFLAG(ENABLE_BASE_TRACING)
 }
 
-static void JNI_TraceEvent_WebViewStartupNotFirstInstance(JNIEnv* env,
-                                                          jlong start_time_ms,
-                                                          jlong duration_ms) {
-#if BUILDFLAG(ENABLE_BASE_TRACING)
-  auto t = perfetto::Track::ThreadScoped(
-      reinterpret_cast<void*>(trace_event::GetNextGlobalTraceId()));
-  TRACE_EVENT_BEGIN("android_webview.timeline",
-                    "WebView.Startup.CreationTime.NotFirstInstance", t,
-                    TimeTicks() + Milliseconds(start_time_ms));
-  TRACE_EVENT_END("android_webview.timeline", t,
-                  TimeTicks() + Milliseconds(start_time_ms + duration_ms));
-#endif  // BUILDFLAG(ENABLE_BASE_TRACING)
-}
-
 static void JNI_TraceEvent_WebViewStartupStartChromiumLocked(
     JNIEnv* env,
     jlong start_time_ms,

src/base/android/unguessable_token_android.cc

@@ -4,9 +4,16 @@
 
 #include "base/android/unguessable_token_android.h"
 
+#include "build/robolectric_buildflags.h"
+
 // Must come after all headers that specialize FromJniType() / ToJniType().
-#include "base/base_minimal_jni/TokenBase_jni.h"
-#include "base/base_minimal_jni/UnguessableToken_jni.h"
+#if BUILDFLAG(IS_ROBOLECTRIC)
+#include "base/base_robolectric_jni/TokenBase_jni.h"         // nogncheck
+#include "base/base_robolectric_jni/UnguessableToken_jni.h"  // nogncheck
+#else
+#include "base/base_jni/TokenBase_jni.h"
+#include "base/base_jni/UnguessableToken_jni.h"
+#endif
 
 namespace base {
 namespace android {
@@ -43,5 +50,3 @@ UnguessableTokenAndroid::ParcelAndUnparcelForTesting(
 
 }  // namespace android
 }  // namespace base
-
-DEFINE_JNI_FOR_UnguessableToken()

src/base/apple/dispatch_source.cc

@@ -1,101 +0,0 @@
-// Copyright 2014 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/apple/dispatch_source.h"
-
-#include "base/apple/scoped_dispatch_object.h"
-
-namespace base::apple {
-
-struct DispatchSource::Storage {
-  // The dispatch queue used to service the source_.
-  ScopedDispatchObject<dispatch_queue_t> queue;
-
-  // Dispatch source type, either DISPATCH_SOURCE_TYPE_MACH_RECV,
-  // DISPATCH_SOURCE_TYPE_READ or DISPATCH_SOURCE_TYPE_WRITE.
-  ScopedDispatchObject<dispatch_source_t> source;
-
-  // Semaphore used to wait on the |source_|'s cancellation in the destructor.
-  ScopedDispatchObject<dispatch_semaphore_t> source_canceled;
-};
-
-DispatchSource::DispatchSource(const char* name,
-                               mach_port_t port,
-                               void (^event_handler)())
-    : DispatchSource(dispatch_queue_create(name, DISPATCH_QUEUE_SERIAL),
-                     port,
-                     event_handler) {
-  // Since the queue was created above in the delegated constructor, and it was
-  // subsequently retained, release it here.
-  dispatch_release(storage_->queue.get());
-}
-
-DispatchSource::DispatchSource(dispatch_queue_t queue,
-                               int fd,
-                               dispatch_source_type_t type,
-                               void (^event_handler)())
-    : storage_(std::make_unique<Storage>()) {
-  DCHECK(type == DISPATCH_SOURCE_TYPE_READ ||
-         type == DISPATCH_SOURCE_TYPE_WRITE);
-  storage_->queue.reset(queue, base::scoped_policy::RETAIN);
-  storage_->source.reset(dispatch_source_create(
-      type, static_cast<uintptr_t>(fd), 0, storage_->queue.get()));
-  storage_->source_canceled.reset(dispatch_semaphore_create(0));
-
-  dispatch_source_set_event_handler(storage_->source.get(), event_handler);
-  dispatch_source_set_cancel_handler(storage_->source.get(), ^{
-    dispatch_semaphore_signal(storage_->source_canceled.get());
-  });
-}
-
-DispatchSource::DispatchSource(dispatch_queue_t queue,
-                               mach_port_t port,
-                               void (^event_handler)())
-    : storage_(std::make_unique<Storage>()) {
-  storage_->queue.reset(queue, base::scoped_policy::RETAIN);
-  storage_->source.reset(dispatch_source_create(
-      DISPATCH_SOURCE_TYPE_MACH_RECV, port, 0, storage_->queue.get()));
-  storage_->source_canceled.reset(dispatch_semaphore_create(0));
-
-  dispatch_source_set_event_handler(storage_->source.get(), event_handler);
-  dispatch_source_set_cancel_handler(storage_->source.get(), ^{
-    dispatch_semaphore_signal(storage_->source_canceled.get());
-  });
-}
-
-DispatchSource::~DispatchSource() {
-  if (suspended_) {
-    Resume();
-  }
-  // Cancel the source and wait for the semaphore to be signaled. This will
-  // ensure the source managed by this class is not used after it is freed.
-  dispatch_source_cancel(storage_->source.get());
-  storage_->source.reset();
-
-  dispatch_semaphore_wait(storage_->source_canceled.get(),
-                          DISPATCH_TIME_FOREVER);
-}
-
-void DispatchSource::Resume() {
-  if (!suspended_) {
-    return;
-  }
-  suspended_ = false;
-  dispatch_resume(storage_->source.get());
-}
-
-void DispatchSource::Suspend() {
-  if (suspended_) {
-    return;
-  }
-
-  suspended_ = true;
-  dispatch_suspend(storage_->source.get());
-}
-
-dispatch_queue_t DispatchSource::Queue() const {
-  return storage_->queue.get();
-}
-
-}  // namespace base::apple

src/base/apple/dispatch_source.h

@@ -1,63 +0,0 @@
-// Copyright 2014 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_APPLE_DISPATCH_SOURCE_H_
-#define BASE_APPLE_DISPATCH_SOURCE_H_
-
-#include <dispatch/dispatch.h>
-
-#include <memory>
-
-#include "base/base_export.h"
-
-namespace base::apple {
-
-// This class encapsulates a dispatch source of type dispatch_source_type_t.
-// When this object is destroyed, the source will be cancelled and it will wait
-// for the source to stop executing work. The source can run on either a
-// user-supplied queue, or it can create its own for the source.
-class BASE_EXPORT DispatchSource {
- public:
-  // Creates a new dispatch source for the |port| and schedules it on a new
-  // queue that will be created with |name|. When a Mach message is received,
-  // the |event_handler| will be called.
-  DispatchSource(const char* name, mach_port_t port, void (^event_handler)());
-
-  // Creates a new dispatch source with the same semantics as above, but rather
-  // than creating a new queue, it schedules the source on |queue|.
-  DispatchSource(dispatch_queue_t queue,
-                 mach_port_t port,
-                 void (^event_handler)());
-
-  // Create a dispatch source for a file descriptor.
-  // `type` should either be DISPATCH_SOURCE_TYPE_READ or
-  // DISPATCH_SOURCE_TYPE_WRITE.
-  DispatchSource(dispatch_queue_t queue,
-                 int fd,
-                 dispatch_source_type_t type,
-                 void (^event_handler)());
-
-  DispatchSource(const DispatchSource&) = delete;
-  DispatchSource& operator=(const DispatchSource&) = delete;
-
-  // Cancels the source and waits for it to become fully cancelled before
-  // releasing the source.
-  ~DispatchSource();
-
-  // Resumes the source. This must be called before any Mach messages will
-  // be received.
-  void Resume();
-  void Suspend();
-
-  dispatch_queue_t Queue() const;
-
- private:
-  bool suspended_ = true;
-  struct Storage;
-  std::unique_ptr<Storage> storage_;
-};
-
-}  // namespace base::apple
-
-#endif  // BASE_APPLE_DISPATCH_SOURCE_H_

src/base/apple/dispatch_source_mach.cc

@@ -0,0 +1,66 @@
+// Copyright 2014 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/apple/dispatch_source_mach.h"
+
+#include "base/apple/scoped_dispatch_object.h"
+
+namespace base::apple {
+
+struct DispatchSourceMach::Storage {
+  // The dispatch queue used to service the source_.
+  ScopedDispatchObject<dispatch_queue_t> queue;
+
+  // A MACH_RECV dispatch source.
+  ScopedDispatchObject<dispatch_source_t> source;
+
+  // Semaphore used to wait on the |source_|'s cancellation in the destructor.
+  ScopedDispatchObject<dispatch_semaphore_t> source_canceled;
+};
+
+DispatchSourceMach::DispatchSourceMach(const char* name,
+                                       mach_port_t port,
+                                       void (^event_handler)())
+    : DispatchSourceMach(dispatch_queue_create(name, DISPATCH_QUEUE_SERIAL),
+                         port,
+                         event_handler) {
+  // Since the queue was created above in the delegated constructor, and it was
+  // subsequently retained, release it here.
+  dispatch_release(storage_->queue.get());
+}
+
+DispatchSourceMach::DispatchSourceMach(dispatch_queue_t queue,
+                                       mach_port_t port,
+                                       void (^event_handler)())
+    : storage_(std::make_unique<Storage>()) {
+  storage_->queue.reset(queue, base::scoped_policy::RETAIN);
+  storage_->source.reset(dispatch_source_create(
+      DISPATCH_SOURCE_TYPE_MACH_RECV, port, 0, storage_->queue.get()));
+  storage_->source_canceled.reset(dispatch_semaphore_create(0));
+
+  dispatch_source_set_event_handler(storage_->source.get(), event_handler);
+  dispatch_source_set_cancel_handler(storage_->source.get(), ^{
+    dispatch_semaphore_signal(storage_->source_canceled.get());
+  });
+}
+
+DispatchSourceMach::~DispatchSourceMach() {
+  // Cancel the source and wait for the semaphore to be signaled. This will
+  // ensure the source managed by this class is not used after it is freed.
+  dispatch_source_cancel(storage_->source.get());
+  storage_->source.reset();
+
+  dispatch_semaphore_wait(storage_->source_canceled.get(),
+                          DISPATCH_TIME_FOREVER);
+}
+
+void DispatchSourceMach::Resume() {
+  dispatch_resume(storage_->source.get());
+}
+
+dispatch_queue_t DispatchSourceMach::Queue() const {
+  return storage_->queue.get();
+}
+
+}  // namespace base::apple

src/base/apple/dispatch_source_mach.h

@@ -0,0 +1,55 @@
+// Copyright 2014 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_APPLE_DISPATCH_SOURCE_MACH_H_
+#define BASE_APPLE_DISPATCH_SOURCE_MACH_H_
+
+#include <dispatch/dispatch.h>
+
+#include <memory>
+
+#include "base/base_export.h"
+
+namespace base::apple {
+
+// This class encapsulates a MACH_RECV dispatch source. When this object is
+// destroyed, the source will be cancelled and it will wait for the source
+// to stop executing work. The source can run on either a user-supplied queue,
+// or it can create its own for the source.
+class BASE_EXPORT DispatchSourceMach {
+ public:
+  // Creates a new dispatch source for the |port| and schedules it on a new
+  // queue that will be created with |name|. When a Mach message is received,
+  // the |event_handler| will be called.
+  DispatchSourceMach(const char* name,
+                     mach_port_t port,
+                     void (^event_handler)());
+
+  // Creates a new dispatch source with the same semantics as above, but rather
+  // than creating a new queue, it schedules the source on |queue|.
+  DispatchSourceMach(dispatch_queue_t queue,
+                     mach_port_t port,
+                     void (^event_handler)());
+
+  DispatchSourceMach(const DispatchSourceMach&) = delete;
+  DispatchSourceMach& operator=(const DispatchSourceMach&) = delete;
+
+  // Cancels the source and waits for it to become fully cancelled before
+  // releasing the source.
+  ~DispatchSourceMach();
+
+  // Resumes the source. This must be called before any Mach messages will
+  // be received.
+  void Resume();
+
+  dispatch_queue_t Queue() const;
+
+ private:
+  struct Storage;
+  std::unique_ptr<Storage> storage_;
+};
+
+}  // namespace base::apple
+
+#endif  // BASE_APPLE_DISPATCH_SOURCE_MACH_H_

src/base/apple/mach_port_rendezvous.cc

@@ -295,7 +295,7 @@ MachPortRendezvousServerIOS::MachPortRendezvousServerIOS(
   DCHECK_LT(ports_.size(), kMaximumRendezvousPorts);
   bool res = apple::CreateMachPort(&server_port_, &send_right_);
   CHECK(res) << "Failed to create mach server port";
-  dispatch_source_ = std::make_unique<apple::DispatchSource>(
+  dispatch_source_ = std::make_unique<apple::DispatchSourceMach>(
       "MachPortRendezvousServer", server_port_.get(), ^{
         HandleRequest();
       });
@@ -409,7 +409,7 @@ MachPortRendezvousServerMac::MachPortRendezvousServerMac() {
       apple::ScopedMachReceiveRight::Receiver(server_port_).get());
   BOOTSTRAP_CHECK(kr == KERN_SUCCESS, kr)
       << "bootstrap_check_in " << bootstrap_name;
-  dispatch_source_ = std::make_unique<apple::DispatchSource>(
+  dispatch_source_ = std::make_unique<apple::DispatchSourceMach>(
       bootstrap_name.c_str(), server_port_.get(), ^{
         HandleRequest();
       });

src/base/apple/mach_port_rendezvous.h

@@ -15,7 +15,7 @@
 #include <string>
 #include <vector>
 
-#include "base/apple/dispatch_source.h"
+#include "base/apple/dispatch_source_mach.h"
 #include "base/apple/scoped_mach_port.h"
 #include "base/base_export.h"
 #include "base/containers/buffer_iterator.h"
@@ -99,7 +99,7 @@ class BASE_EXPORT MachPortRendezvousServerBase {
   apple::ScopedMachReceiveRight server_port_;
 
   // Mach message dispatch source for |server_port_|.
-  std::unique_ptr<apple::DispatchSource> dispatch_source_;
+  std::unique_ptr<apple::DispatchSourceMach> dispatch_source_;
 
   // Ask for the associated ports associated with `audit_token`.
   // Return `std::nullopt` if the client is not authorized to

src/base/base64.cc

@@ -81,10 +81,7 @@ bool Base64Decode(std::string_view input,
     // in-place, but it violates the API contract that `output` is only modified
     // on success.
     std::string input_without_whitespace;
-    RemoveChars(input,
-                std::string_view(std::begin(kInfraAsciiWhitespace),
-                                 std::end(kInfraAsciiWhitespace)),
-                &input_without_whitespace);
+    RemoveChars(input, kInfraAsciiWhitespace, &input_without_whitespace);
     // This means that the required size to decode is at most what was needed
     // above, which means `decode_buf` will fit the decoded bytes at its current
     // size and we don't need to call `modp_b64_decode_len()` again.

src/base/base_paths_win.cc

@@ -238,17 +238,6 @@ bool PathProviderWin(int key, FilePath* result) {
         return false;
       }
       break;
-    case base::DIR_ONE_DRIVE: {
-      base::win::ScopedCoMem<wchar_t> path_buf;
-      // FOLDERID_OneDrive points on the user OneDrive folder. The default path
-      // is %USERPROFILE%\OneDrive. It is formerly known as FOLDERID_SkyDrive.
-      if (FAILED(SHGetKnownFolderPath(FOLDERID_OneDrive, 0, NULL, &path_buf))) {
-        return false;
-      }
-
-      cur = FilePath(path_buf.get());
-      break;
-    }
     default:
       return false;
   }

src/base/base_paths_win.h

@@ -57,7 +57,6 @@ enum {
   DIR_WINDOWS_FONTS,           // Usually C:\Windows\Fonts.
   DIR_SYSTEM_TEMP,             // %SystemRoot%\SystemTemp or %ProgramFiles%;
                                // only for admin processes.
-  DIR_ONE_DRIVE,               // The synced personal OneDrive directory.
   PATH_WIN_END
 };
 

src/base/base_switches.cc

@@ -5,6 +5,7 @@
 #include "base/base_switches.h"
 
 #include "build/build_config.h"
+#include "build/chromeos_buildflags.h"
 
 namespace switches {
 

src/base/base_switches.h

@@ -8,6 +8,7 @@
 #define BASE_BASE_SWITCHES_H_
 
 #include "build/build_config.h"
+#include "build/chromeos_buildflags.h"
 
 namespace switches {
 

src/base/check.h

@@ -216,9 +216,6 @@ class BASE_EXPORT NotReachedNoreturnError : public CheckError {
 // The weird ternary is to still generate an "is not contextually convertible to
 // 'bool' when provided weird parameters (regardless of ANALYZER_ASSUME_TRUE's
 // implementation). See base/check_nocompile.nc.
-//
-// The lambda is here to here permit the compiler to out-of-line much of the
-// CHECK-failure path and optimize better for the fast path.
 #define LOGGING_CHECK_FUNCTION_IMPL(check_stream, condition) \
   switch (0)                                                 \
   case 0:                                                    \
@@ -226,7 +223,7 @@ class BASE_EXPORT NotReachedNoreturnError : public CheckError {
     if (ANALYZER_ASSUME_TRUE((condition) ? true : false))    \
       [[likely]];                                            \
     else                                                     \
-      [&]() { return (check_stream); }()
+      (check_stream)
 
 // A helper macro like LOGGING_CHECK_FUNCTION_IMPL above but discarding any
 // log-stream parameters rather than evaluate them on failure.

src/base/check_op.h

@@ -14,9 +14,9 @@
 #include "base/check.h"
 #include "base/dcheck_is_on.h"
 #include "base/memory/raw_ptr_exclusion.h"
+#include "base/strings/to_string.h"
 #include "base/types/is_arc_pointer.h"
 #include "base/types/supports_ostream_operator.h"
-#include "base/types/supports_to_string.h"
 
 // This header defines the (DP)CHECK_EQ etc. macros.
 //

src/base/command_line.cc

@@ -2,6 +2,11 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#ifdef UNSAFE_BUFFERS_BUILD
+// TODO(crbug.com/40284755): Remove this and spanify to fix the errors.
+#pragma allow_unsafe_buffers
+#endif
+
 #include "base/command_line.h"
 
 #include <algorithm>
@@ -10,7 +15,6 @@
 #include <string_view>
 
 #include "base/check_op.h"
-#include "base/compiler_specific.h"
 #include "base/containers/contains.h"
 #include "base/containers/span.h"
 #include "base/debug/debugging_buildflags.h"
@@ -193,8 +197,7 @@ CommandLine::CommandLine(const FilePath& program) : argv_(1), begin_args_(1) {
 
 CommandLine::CommandLine(int argc, const CommandLine::CharType* const* argv)
     : argv_(1), begin_args_(1) {
-  // SAFETY: required from caller.
-  UNSAFE_BUFFERS(InitFromArgv(argc, argv));
+  InitFromArgv(argc, argv);
 }
 
 CommandLine::CommandLine(const StringVector& argv) : argv_(1), begin_args_(1) {
@@ -251,8 +254,7 @@ void CommandLine::InitUsingArgvForTesting(int argc, const char* const* argv) {
   // On Windows we need to convert the command line arguments to std::wstring.
   CommandLine::StringVector argv_vector;
   for (int i = 0; i < argc; ++i) {
-    // SAFETY: required from caller.
-    argv_vector.push_back(UTF8ToWide(UNSAFE_BUFFERS(argv[i])));
+    argv_vector.push_back(UTF8ToWide(argv[i]));
   }
   current_process_commandline_->InitFromArgv(argv_vector);
 }
@@ -271,8 +273,7 @@ bool CommandLine::Init(int argc, const char* const* argv) {
 #if BUILDFLAG(IS_WIN)
   current_process_commandline_->ParseFromString(::GetCommandLineW());
 #elif BUILDFLAG(IS_POSIX) || BUILDFLAG(IS_FUCHSIA)
-  // SAFETY: required from caller.
-  UNSAFE_BUFFERS(current_process_commandline_->InitFromArgv(argc, argv));
+  current_process_commandline_->InitFromArgv(argc, argv);
 #else
 #error Unsupported platform
 #endif
@@ -318,8 +319,7 @@ void CommandLine::InitFromArgv(int argc,
                                const CommandLine::CharType* const* argv) {
   StringVector new_argv;
   for (int i = 0; i < argc; ++i) {
-    // SAFETY: required from caller.
-    new_argv.push_back(UNSAFE_BUFFERS(argv[i]));
+    new_argv.push_back(argv[i]);
   }
   InitFromArgv(new_argv);
 }
@@ -378,23 +378,6 @@ std::string CommandLine::GetSwitchValueASCII(
 #endif
 }
 
-std::string CommandLine::GetSwitchValueUTF8(
-    std::string_view switch_string) const {
-  StringType value = GetSwitchValueNative(switch_string);
-
-#if BUILDFLAG(IS_WIN)
-  const std::string maybe_utf8_value = WideToUTF8(value);
-#elif BUILDFLAG(IS_POSIX) || BUILDFLAG(IS_FUCHSIA)
-  const std::string maybe_utf8_value = value;
-#endif
-
-  if (!IsStringUTF8(maybe_utf8_value)) {
-    DLOG(WARNING) << "Value of switch (" << switch_string << ") is not UTF8.";
-    return {};
-  }
-  return maybe_utf8_value;
-}
-
 FilePath CommandLine::GetSwitchValuePath(std::string_view switch_string) const {
   return FilePath(GetSwitchValueNative(switch_string));
 }
@@ -452,14 +435,6 @@ void CommandLine::AppendSwitchNative(std::string_view switch_string,
 
 void CommandLine::AppendSwitchASCII(std::string_view switch_string,
                                     std::string_view value_string) {
-  AppendSwitchUTF8(switch_string, value_string);
-}
-
-void CommandLine::AppendSwitchUTF8(std::string_view switch_string,
-                                   std::string_view value_string) {
-  DCHECK(IsStringUTF8(value_string))
-      << "Switch (" << switch_string << ") value (" << value_string
-      << ") is not UTF8.";
 #if BUILDFLAG(IS_WIN)
   AppendSwitchNative(switch_string, UTF8ToWide(value_string));
 #elif BUILDFLAG(IS_POSIX) || BUILDFLAG(IS_FUCHSIA)
@@ -612,7 +587,7 @@ void CommandLine::ParseFromString(StringViewType command_line) {
 
   DPLOG_IF(FATAL, !args) << "CommandLineToArgvW failed on command line: "
                          << command_line;
-  StringVector argv(args, UNSAFE_TODO(args + num_args));
+  StringVector argv(args, args + num_args);
   InitFromArgv(argv);
   raw_command_line_string_ = StringViewType();
   LocalFree(args);

src/base/command_line.h

@@ -71,7 +71,6 @@ class BASE_EXPORT CommandLine {
   explicit CommandLine(const FilePath& program);
 
   // Construct a new command line from an argument list.
-  // TODO(tsepez): two-arg form should be UNSAFE_BUFFER_USAGE.
   CommandLine(int argc, const CharType* const* argv);
   explicit CommandLine(const StringVector& argv);
 
@@ -102,7 +101,6 @@ class BASE_EXPORT CommandLine {
   // CommandLineToArgvW to parse the command line and convert it back to
   // argc and argv. Tests who don't want this dependency on shell32 and need
   // to honor the arguments passed in should use this function.
-  // TODO(tsepez): should be UNSAFE_BUFFER_USAGE.
   static void InitUsingArgvForTesting(int argc, const char* const* argv);
 #endif
 
@@ -111,8 +109,7 @@ class BASE_EXPORT CommandLine {
   // don't trust the CRT's parsing of the command line, but it still must be
   // called to set up the command line. Returns false if initialization has
   // already occurred, and true otherwise. Only the caller receiving a 'true'
-  // return value should take responsibility for calling Reset().
-  // TODO(tsepez): should be UNSAFE_BUFFER_USAGE.
+  // return value should take responsibility for calling Reset.
   static bool Init(int argc, const char* const* argv);
 
   // Destroys the current process CommandLine singleton. This is necessary if
@@ -131,7 +128,6 @@ class BASE_EXPORT CommandLine {
   static bool InitializedForCurrentProcess();
 
   // Initialize from an argv vector.
-  // TODO(tsepez): two-arg form should be UNSAFE_BUFFER_USAGE.
   void InitFromArgv(int argc, const CharType* const* argv);
   void InitFromArgv(const StringVector& argv);
 
@@ -201,7 +197,6 @@ class BASE_EXPORT CommandLine {
   // value or isn't present, this method returns the empty string.
   // Switch names must be lowercase.
   std::string GetSwitchValueASCII(std::string_view switch_string) const;
-  std::string GetSwitchValueUTF8(std::string_view switch_string) const;
   FilePath GetSwitchValuePath(std::string_view switch_string) const;
   StringType GetSwitchValueNative(std::string_view switch_string) const;
 
@@ -215,7 +210,6 @@ class BASE_EXPORT CommandLine {
   void AppendSwitchNative(std::string_view switch_string, StringViewType value);
   void AppendSwitchASCII(std::string_view switch_string,
                          std::string_view value);
-  void AppendSwitchUTF8(std::string_view switch_string, std::string_view value);
 
   // Removes the switch that matches |switch_key_without_prefix|, regardless of
   // prefix and value. If no such switch is present, this has no effect.

src/base/containers/enum_set.h

@@ -16,7 +16,6 @@
 #include "base/check.h"
 #include "base/check_op.h"
 #include "base/memory/raw_ptr.h"
-#include "base/types/cxx23_to_underlying.h"
 #include "build/build_config.h"
 
 namespace base {
@@ -26,16 +25,16 @@ template <typename E, E MinEnumValue, E MaxEnumValue>
 class EnumSet;
 
 template <typename E, E Min, E Max>
-EnumSet<E, Min, Max> Union(EnumSet<E, Min, Max> set1,
-                           EnumSet<E, Min, Max> set2);
+constexpr EnumSet<E, Min, Max> Union(EnumSet<E, Min, Max> set1,
+                                     EnumSet<E, Min, Max> set2);
 
 template <typename E, E Min, E Max>
-EnumSet<E, Min, Max> Intersection(EnumSet<E, Min, Max> set1,
-                                  EnumSet<E, Min, Max> set2);
+constexpr EnumSet<E, Min, Max> Intersection(EnumSet<E, Min, Max> set1,
+                                            EnumSet<E, Min, Max> set2);
 
 template <typename E, E Min, E Max>
-EnumSet<E, Min, Max> Difference(EnumSet<E, Min, Max> set1,
-                                EnumSet<E, Min, Max> set2);
+constexpr EnumSet<E, Min, Max> Difference(EnumSet<E, Min, Max> set1,
+                                          EnumSet<E, Min, Max> set2);
 
 // An EnumSet is a set that can hold enum values between a min and a
 // max value (inclusive of both).  It's essentially a wrapper around
@@ -52,24 +51,26 @@ class EnumSet {
   static_assert(
       std::is_enum_v<E>,
       "First template parameter of EnumSet must be an enumeration type");
+  using enum_underlying_type = std::underlying_type_t<E>;
 
   static constexpr bool InRange(E value) {
     return (value >= MinEnumValue) && (value <= MaxEnumValue);
   }
 
+  static constexpr enum_underlying_type GetUnderlyingValue(E value) {
+    return static_cast<enum_underlying_type>(value);
+  }
+
  public:
   using EnumType = E;
   static const E kMinValue = MinEnumValue;
   static const E kMaxValue = MaxEnumValue;
   static const size_t kValueCount =
-      to_underlying(kMaxValue) - to_underlying(kMinValue) + 1;
+      GetUnderlyingValue(kMaxValue) - GetUnderlyingValue(kMinValue) + 1;
 
   static_assert(kMinValue <= kMaxValue,
                 "min value must be no greater than max value");
 
-  // Allow use with ::testing::ValuesIn, which expects a value_type defined.
-  using value_type = EnumType;
-
  private:
   // Declaration needed by Iterator.
   using EnumBitSet = std::bitset<kValueCount>;
@@ -227,37 +228,37 @@ class EnumSet {
 
   // Returns an EnumSet constructed from |bitmask|.
   static constexpr EnumSet FromEnumBitmask(const uint64_t bitmask) {
-    static_assert(to_underlying(kMaxValue) < 64,
+    static_assert(GetUnderlyingValue(kMaxValue) < 64,
                   "The highest enum value must be < 64 for FromEnumBitmask ");
-    static_assert(to_underlying(kMinValue) >= 0,
+    static_assert(GetUnderlyingValue(kMinValue) >= 0,
                   "The lowest enum value must be >= 0 for FromEnumBitmask ");
-    return EnumSet(EnumBitSet(bitmask >> to_underlying(kMinValue)));
+    return EnumSet(EnumBitSet(bitmask >> GetUnderlyingValue(kMinValue)));
   }
   // Returns a bitmask for the EnumSet.
   uint64_t ToEnumBitmask() const {
-    static_assert(to_underlying(kMaxValue) < 64,
+    static_assert(GetUnderlyingValue(kMaxValue) < 64,
                   "The highest enum value must be < 64 for ToEnumBitmask ");
-    static_assert(to_underlying(kMinValue) >= 0,
+    static_assert(GetUnderlyingValue(kMinValue) >= 0,
                   "The lowest enum value must be >= 0 for FromEnumBitmask ");
-    return enums_.to_ullong() << to_underlying(kMinValue);
+    return enums_.to_ullong() << GetUnderlyingValue(kMinValue);
   }
 
   // Returns a uint64_t bit mask representing the values within the range
   // [64*n, 64*n + 63] of the EnumSet.
   std::optional<uint64_t> GetNth64bitWordBitmask(size_t n) const {
     // If the EnumSet contains less than n 64-bit masks, return std::nullopt.
-    if (to_underlying(kMaxValue) / 64 < n) {
+    if (GetUnderlyingValue(kMaxValue) / 64 < n) {
       return std::nullopt;
     }
 
     std::bitset<kValueCount> mask = ~uint64_t{0};
     std::bitset<kValueCount> bits = enums_;
-    if (to_underlying(kMinValue) < n * 64) {
-      bits >>= n * 64 - to_underlying(kMinValue);
+    if (GetUnderlyingValue(kMinValue) < n * 64) {
+      bits >>= n * 64 - GetUnderlyingValue(kMinValue);
     }
     uint64_t result = (bits & mask).to_ullong();
-    if (to_underlying(kMinValue) > n * 64) {
-      result <<= to_underlying(kMinValue) - n * 64;
+    if (GetUnderlyingValue(kMinValue) > n * 64) {
+      result <<= GetUnderlyingValue(kMinValue) - n * 64;
     }
     return result;
   }
@@ -343,12 +344,14 @@ class EnumSet {
   std::string ToString() const { return enums_.to_string(); }
 
  private:
-  friend EnumSet Union<E, MinEnumValue, MaxEnumValue>(EnumSet set1,
-                                                      EnumSet set2);
-  friend EnumSet Intersection<E, MinEnumValue, MaxEnumValue>(EnumSet set1,
-                                                             EnumSet set2);
-  friend EnumSet Difference<E, MinEnumValue, MaxEnumValue>(EnumSet set1,
-                                                           EnumSet set2);
+  friend constexpr EnumSet Union<E, MinEnumValue, MaxEnumValue>(EnumSet set1,
+                                                                EnumSet set2);
+  friend constexpr EnumSet Intersection<E, MinEnumValue, MaxEnumValue>(
+      EnumSet set1,
+      EnumSet set2);
+  friend constexpr EnumSet Difference<E, MinEnumValue, MaxEnumValue>(
+      EnumSet set1,
+      EnumSet set2);
 
   static constexpr uint64_t bitstring(const std::initializer_list<E>& values) {
     uint64_t result = 0;
@@ -379,13 +382,13 @@ class EnumSet {
   // Converts a value to/from an index into |enums_|.
   static constexpr size_t ToIndex(E value) {
     CHECK(InRange(value));
-    return static_cast<size_t>(to_underlying(value)) -
-           static_cast<size_t>(to_underlying(MinEnumValue));
+    return static_cast<size_t>(GetUnderlyingValue(value)) -
+           static_cast<size_t>(GetUnderlyingValue(MinEnumValue));
   }
 
   static E FromIndex(size_t i) {
     DCHECK_LT(i, kValueCount);
-    return static_cast<E>(to_underlying(MinEnumValue) + i);
+    return static_cast<E>(GetUnderlyingValue(MinEnumValue) + i);
   }
 
   EnumBitSet enums_;
@@ -403,20 +406,20 @@ const size_t EnumSet<E, MinEnumValue, MaxEnumValue>::kValueCount;
 // The usual set operations.
 
 template <typename E, E Min, E Max>
-EnumSet<E, Min, Max> Union(EnumSet<E, Min, Max> set1,
-                           EnumSet<E, Min, Max> set2) {
+constexpr EnumSet<E, Min, Max> Union(EnumSet<E, Min, Max> set1,
+                                     EnumSet<E, Min, Max> set2) {
   return EnumSet<E, Min, Max>(set1.enums_ | set2.enums_);
 }
 
 template <typename E, E Min, E Max>
-EnumSet<E, Min, Max> Intersection(EnumSet<E, Min, Max> set1,
-                                  EnumSet<E, Min, Max> set2) {
+constexpr EnumSet<E, Min, Max> Intersection(EnumSet<E, Min, Max> set1,
+                                            EnumSet<E, Min, Max> set2) {
   return EnumSet<E, Min, Max>(set1.enums_ & set2.enums_);
 }
 
 template <typename E, E Min, E Max>
-EnumSet<E, Min, Max> Difference(EnumSet<E, Min, Max> set1,
-                                EnumSet<E, Min, Max> set2) {
+constexpr EnumSet<E, Min, Max> Difference(EnumSet<E, Min, Max> set1,
+                                          EnumSet<E, Min, Max> set2) {
   return EnumSet<E, Min, Max>(set1.enums_ & ~set2.enums_);
 }
 

src/base/containers/heap_array.h

@@ -169,17 +169,13 @@ class TRIVIAL_ABI GSL_OWNER HeapArray {
   // If `count` is unspecified, all remaining elements are included. A CHECK()
   // occurs if any of the parameters results in an out-of-range position in
   // the HeapArray.
-  base::span<T> subspan(size_t offset) LIFETIME_BOUND {
-    return as_span().subspan(offset);
-  }
-  base::span<const T> subspan(size_t offset) const LIFETIME_BOUND {
-    return as_span().subspan(offset);
-  }
-  base::span<T> subspan(size_t offset, size_t count) LIFETIME_BOUND {
+  base::span<T> subspan(size_t offset,
+                        size_t count = base::dynamic_extent) LIFETIME_BOUND {
     return as_span().subspan(offset, count);
   }
   base::span<const T> subspan(size_t offset,
-                              size_t count) const LIFETIME_BOUND {
+                              size_t count = base::dynamic_extent) const
+      LIFETIME_BOUND {
     return as_span().subspan(offset, count);
   }
 

src/base/containers/map_util.h

@@ -66,40 +66,6 @@ constexpr MappedElementType* FindPtrOrNull(Map& map, const Key& key) {
   return it != map.end() ? base::to_address(it->second) : nullptr;
 }
 
-// Insert or assign into a map type. This has semantics very similar to the
-// following statements:
-//
-//    map[key] = Element(params...)
-//    map[key] = element;
-//    map[key] = std::move(element);
-//    map.insert_or_assign(key, element);
-//
-// Where key can be any heterogeneous comparable overload of the key_type for
-// map. In particular, there is no need to construct a temporary `key` of the
-// type stored in the map as long as `key` is comparable with the
-// `Map::key_type`.
-//
-// The `element` is copied or moved into the map, depending on whether it is
-// passed by lvalue or rvalue reference.
-//
-// TODO(crbug.com/376532871): This can be removed once map::operator[] and
-// map::insert_or_assign support heterogenous key overloads, in C++26.
-template <typename Map,
-          typename Key,
-          typename MappedElementType =
-              std::pointer_traits<internal::MappedType<Map>>::element_type>
-Map::iterator InsertOrAssign(Map& map,
-                             const Key& key,
-                             MappedElementType&& element) {
-  auto it = map.lower_bound(key);
-  if (it == map.end() || it->first != key) {
-    it = map.emplace_hint(it, key, std::forward<MappedElementType>(element));
-  } else {
-    it->second = std::forward<MappedElementType>(element);
-  }
-  return it;
-}
-
 }  // namespace base
 
 #endif  // BASE_CONTAINERS_MAP_UTIL_H_

src/base/containers/span.h

@@ -31,7 +31,6 @@
 #include "base/numerics/integral_constant_like.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/strings/cstring_view.h"
-#include "base/strings/to_string.h"
 #include "base/types/to_address.h"
 
 // A span is a view of contiguous elements that can be accessed like an array,
@@ -227,8 +226,6 @@
 // Differences from [span.sub]:
 // - As in [span.cons], `size_t` parameters are changed to
 //   `StrictNumeric<size_type>`.
-// - There are separate overloads for one-arg and two-arg forms of subspan,
-//   and the two-arg form does not accept dynamic_extent as a count.
 // - For convenience, provides `span::split_at()` to split a single span into
 //   two at a given offset.
 // - For convenience, provides `span::take_first[_elem]()` to remove the first
@@ -721,21 +718,19 @@ class GSL_POINTER span {
       return UNSAFE_BUFFERS(span<element_type, Count>(data() + Offset, Count));
     }
   }
-  constexpr auto subspan(StrictNumeric<size_type> offset) const {
+  constexpr auto subspan(
+      StrictNumeric<size_type> offset,
+      StrictNumeric<size_type> count = dynamic_extent) const {
     CHECK_LE(size_type{offset}, extent);
     const size_type remaining = extent - size_type{offset};
-    // SAFETY: `data()` points to at least `extent` elements, so `offset`
-    // specifies a valid element index or the past-the-end index, and
-    // `remaining` cannot index past-the-end elements.
-    return UNSAFE_BUFFERS(
-        span<element_type>(data() + size_type{offset}, remaining));
-  }
-  constexpr auto subspan(StrictNumeric<size_type> offset,
-                         StrictNumeric<size_type> count) const {
-    DCHECK(size_type{count} != dynamic_extent)
-        << "base does not allow dynamic_extent in two-arg subspan()";
-    CHECK(size_type{offset} <= size() &&
-          size_type{count} <= size() - size_type{offset});
+    if (count == dynamic_extent) {
+      // SAFETY: `data()` points to at least `extent` elements, so `offset`
+      // specifies a valid element index or the past-the-end index, and
+      // `remaining` cannot index past-the-end elements.
+      return UNSAFE_BUFFERS(
+          span<element_type>(data() + size_type{offset}, remaining));
+    }
+    CHECK_LE(size_type{count}, remaining);
     // SAFETY: `data()` points to at least `extent` elements, so `offset`
     // specifies a valid element index or the past-the-end index, and `count` is
     // no larger than the number of remaining valid elements.
@@ -1155,21 +1150,19 @@ class GSL_POINTER span<ElementType, dynamic_extent, InternalPtrType> {
     // no larger than the number of remaining valid elements.
     return UNSAFE_BUFFERS(span<element_type, Count>(data() + Offset, Count));
   }
-  constexpr auto subspan(StrictNumeric<size_type> offset) const {
+  constexpr auto subspan(
+      StrictNumeric<size_type> offset,
+      StrictNumeric<size_type> count = dynamic_extent) const {
     CHECK_LE(size_type{offset}, size());
     const size_type remaining = size() - size_type{offset};
-    // SAFETY: `data()` points to at least `size()` elements, so `offset`
-    // specifies a valid element index or the past-the-end index, and
-    // `remaining` cannot index past-the-end elements.
-    return UNSAFE_BUFFERS(
-        span<element_type>(data() + size_type{offset}, remaining));
-  }
-  constexpr auto subspan(StrictNumeric<size_type> offset,
-                         StrictNumeric<size_type> count) const {
-    DCHECK(size_type{count} != dynamic_extent)
-        << "base does not allow dynamic_extent in two-arg subspan()";
-    CHECK(size_type{offset} <= size() &&
-          size_type{count} <= size() - size_type{offset});
+    if (count == dynamic_extent) {
+      // SAFETY: `data()` points to at least `size()` elements, so `offset`
+      // specifies a valid element index or the past-the-end index, and
+      // `remaining` cannot index past-the-end elements.
+      return UNSAFE_BUFFERS(
+          span<element_type>(data() + size_type{offset}, remaining));
+    }
+    CHECK_LE(size_type{count}, remaining);
     // SAFETY: `data()` points to at least `size()` elements, so `offset`
     // specifies a valid element index or the past-the-end index, and `count` is
     // no larger than the number of remaining valid elements.

src/base/cpu_reduction_experiment.cc

@@ -0,0 +1,78 @@
+// Copyright 2022 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/cpu_reduction_experiment.h"
+
+#include <atomic>
+
+#include "base/check.h"
+#include "base/dcheck_is_on.h"
+#include "base/feature_list.h"
+#include "base/rand_util.h"
+
+namespace base {
+
+namespace {
+
+// Whether to enable a series of optimizations that reduce total CPU
+// utilization.
+BASE_FEATURE(kReduceCpuUtilization,
+             "ReduceCpuUtilization2",
+             FEATURE_ENABLED_BY_DEFAULT);
+
+class CpuReductionExperimentSubSampler {
+ public:
+  CpuReductionExperimentSubSampler() : counter_(base::RandUint64()) {}
+
+  bool ShouldLogHistograms() {
+    // Relaxed memory order since there is no dependent memory access.
+    uint64_t val = counter_.fetch_add(1, std::memory_order_relaxed);
+    return val % 1000 == 0;
+  }
+
+ private:
+  std::atomic<uint64_t> counter_{0};
+};
+
+// Singleton instance of CpuReductionExperimentSubSampler. This is only set when
+// the ReduceCpuUtilization experiment is enabled -- as a result, it's ok to
+// assume that the experiment is disabled when this is not set.
+CpuReductionExperimentSubSampler* g_subsampler = nullptr;
+
+#if DCHECK_IS_ON()
+// Atomic to support concurrent writes from IsRunningCpuReductionExperiment().
+std::atomic_bool g_accessed_subsampler = false;
+#endif
+
+}  // namespace
+
+bool IsRunningCpuReductionExperiment() {
+#if DCHECK_IS_ON()
+  // Relaxed memory order since there is no dependent memory access.
+  g_accessed_subsampler.store(true, std::memory_order_relaxed);
+#endif
+  return !!g_subsampler;
+}
+
+void InitializeCpuReductionExperiment() {
+#if DCHECK_IS_ON()
+  // TSAN should generate an error if InitializeCpuReductionExperiment() races
+  // with IsRunningCpuReductionExperiment().
+  //
+  // Relaxed memory order since there is no dependent memory access.
+  DCHECK(!g_accessed_subsampler.load(std::memory_order_relaxed));
+#endif
+  if (FeatureList::IsEnabled(kReduceCpuUtilization)) {
+    g_subsampler = new CpuReductionExperimentSubSampler();
+  }
+}
+
+bool ShouldLogHistogramForCpuReductionExperiment() {
+  if (!IsRunningCpuReductionExperiment()) {
+    return true;
+  }
+  return g_subsampler->ShouldLogHistograms();
+}
+
+}  // namespace base

src/base/cpu_reduction_experiment.h

@@ -0,0 +1,29 @@
+// Copyright 2022 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_CPU_REDUCTION_EXPERIMENT_H_
+#define BASE_CPU_REDUCTION_EXPERIMENT_H_
+
+#include "base/base_export.h"
+
+namespace base {
+
+// Returns whether the cpu cycle reduction experiment is running.
+// The goal of this experiment is to better understand the relationship between
+// total CPU cycles used across the fleet and top-line chrome metrics.
+BASE_EXPORT bool IsRunningCpuReductionExperiment();
+
+// Must be called after FeatureList initialization and while chrome is still
+// single-threaded.
+BASE_EXPORT void InitializeCpuReductionExperiment();
+
+// Returns true if the next sample should be recorded to an histogram
+// sub-sampled under the CPU reduction experiment. Returns true randomly for
+// ~1/1000 calls when the experiment is enabled, or always returns true when the
+// experiment is disabled.
+BASE_EXPORT bool ShouldLogHistogramForCpuReductionExperiment();
+
+}  // namespace base
+
+#endif  // BASE_CPU_REDUCTION_EXPERIMENT_H_

src/base/debug/dump_without_crashing.cc

@@ -46,6 +46,16 @@ std::map<base::Location, base::TimeTicks>& LocationToTimestampMap() {
   return *location_to_timestamp;
 }
 
+// Map used to store the most recent time a pair of location and
+// unique_identifier called ShouldDumpWithoutCrashWithLocationAndUniqueId.
+std::map<std::pair<base::Location, size_t>, base::TimeTicks>&
+LocationAndUniqueIdentifierToTimestampMap() {
+  static base::NoDestructor<
+      std::map<std::pair<base::Location, size_t>, base::TimeTicks>>
+      location_and_unique_identifier_to_timestamp;
+  return *location_and_unique_identifier_to_timestamp;
+}
+
 // This function takes `location` and `time_between_dumps` as an input
 // and checks if DumpWithoutCrashing() meets the requirements to take the dump
 // or not.
@@ -54,10 +64,31 @@ bool ShouldDumpWithoutCrashWithLocation(const base::Location& location,
   return ShouldDump(LocationToTimestampMap(), location, time_between_dumps);
 }
 
+// Pair of `location` and `unique_identifier` creates a unique key and checks
+// if DumpWithoutCrashingWithUniqueId() meets the requirements to take dump or
+// not.
+bool ShouldDumpWithoutCrashWithLocationAndUniqueId(
+    size_t unique_identifier,
+    const base::Location& location,
+    base::TimeDelta time_between_dumps) {
+  std::pair<base::Location, size_t> key(location, unique_identifier);
+  return ShouldDump(LocationAndUniqueIdentifierToTimestampMap(), key,
+                    time_between_dumps);
+}
+
 }  // namespace
 
 namespace base::debug {
 
+bool DumpWithoutCrashingUnthrottled() {
+  TRACE_EVENT0("base", "DumpWithoutCrashingUnthrottled");
+  if (dump_without_crashing_function_) {
+    (*dump_without_crashing_function_)();
+    return true;
+  }
+  return false;
+}
+
 bool DumpWithoutCrashing(const base::Location& location,
                          base::TimeDelta time_between_dumps) {
   TRACE_EVENT0("base", "DumpWithoutCrashing");
@@ -82,6 +113,23 @@ bool DumpWithoutCrashing(const base::Location& location,
   return false;
 }
 
+bool DumpWithoutCrashingWithUniqueId(size_t unique_identifier,
+                                     const base::Location& location,
+                                     base::TimeDelta time_between_dumps) {
+  TRACE_EVENT0("base", "DumpWithoutCrashingWithUniqueId");
+  if (dump_without_crashing_function_ &&
+      ShouldDumpWithoutCrashWithLocationAndUniqueId(unique_identifier, location,
+                                                    time_between_dumps)) {
+    (*dump_without_crashing_function_)();
+    base::UmaHistogramEnumeration("Stability.DumpWithoutCrashingStatus",
+                                  DumpWithoutCrashingStatus::kUploaded);
+    return true;
+  }
+  base::UmaHistogramEnumeration("Stability.DumpWithoutCrashingStatus",
+                                DumpWithoutCrashingStatus::kThrottled);
+  return false;
+}
+
 void SetDumpWithoutCrashingFunction(void (*function)()) {
 #if !defined(COMPONENT_BUILD)
   // In component builds, the same base is shared between modules
@@ -92,8 +140,9 @@ void SetDumpWithoutCrashingFunction(void (*function)()) {
   dump_without_crashing_function_ = function;
 }
 
-void ResetDumpWithoutCrashingThrottlingForTesting() {
+void ClearMapsForTesting() {
   LocationToTimestampMap().clear();
+  LocationAndUniqueIdentifierToTimestampMap().clear();
 }
 
 }  // namespace base::debug

src/base/debug/dump_without_crashing.h

@@ -38,6 +38,11 @@ namespace debug {
 // This function must not be called with a tail call because that would cause
 // the caller to be omitted from the call stack in the crash dump, and that is
 // confusing and omits what is likely the most important context.
+//
+// Note: Calls to this function will not be throttled. To avoid performance
+// problems if this is called many times in quick succession, prefer using one
+// of the below variants.
+NOT_TAIL_CALLED BASE_EXPORT bool DumpWithoutCrashingUnthrottled();
 
 // Handler to silently dump the current process without crashing, that keeps
 // track of call location so some throttling can be applied to avoid very
@@ -48,13 +53,35 @@ NOT_TAIL_CALLED BASE_EXPORT bool DumpWithoutCrashing(
     const base::Location& location = base::Location::Current(),
     base::TimeDelta time_between_dumps = base::Days(1));
 
+// Handler to silently dump the current process without crashing that takes a
+// location and unique id to keep a track and apply throttling. This function
+// should be used when a domain wishes to capture dumps for multiple, unique
+// reasons from a single location. An example would be unique bad mojo
+// messages, or a value outside an expected range and the value should be
+// considered interesting in the dump. The goal is to allow a single call to
+// generate multiple dumps as needed and throttle future instances of the same
+// identifiers for a short period of time.
+// `unique_identifier` Hash to uniquely identify the function call. Consider
+// using base::FastHash to generate the hash.
+// `location` Location of the file from where the function is called.
+// `time_between_dumps` Time until the next dump should be captured.
+// Note:
+// - The unique identifier, as of now, is not comparable across different
+//   runs or builds and is stable only for a process lifetime.
+// - The unique identifier is not recorded in the crash report. See
+//   crash_logging.h for such a purpose.
+NOT_TAIL_CALLED BASE_EXPORT bool DumpWithoutCrashingWithUniqueId(
+    size_t unique_identifier,
+    const base::Location& location = base::Location::Current(),
+    base::TimeDelta time_between_dumps = base::Days(1));
+
 // Sets a function that'll be invoked to dump the current process when
 // DumpWithoutCrashing* is called. May be called with null to remove a
 // previously set function.
 BASE_EXPORT void SetDumpWithoutCrashingFunction(void (*function)());
 
-// Reset DumpWithoutCrashing throttling for testing.
-BASE_EXPORT void ResetDumpWithoutCrashingThrottlingForTesting();
+// Clear both maps used to throttle calls to DumpWithoutCrashing for testing.
+BASE_EXPORT void ClearMapsForTesting();
 
 }  // namespace debug
 }  // namespace base

src/base/debug/stack_trace.cc

@@ -206,7 +206,7 @@ uintptr_t GetStackEnd() {
   // values from its pthread_t argument.
   static uintptr_t main_stack_end = 0;
 
-  bool is_main_thread = GetCurrentProcId() == PlatformThread::CurrentId().raw();
+  bool is_main_thread = GetCurrentProcId() == PlatformThread::CurrentId();
   if (is_main_thread && main_stack_end) {
     return main_stack_end;
   }
@@ -234,8 +234,7 @@ uintptr_t GetStackEnd() {
 #else
 
 #if (BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)) && defined(__GLIBC__)
-  static_assert(std::is_same_v<ProcessId, PlatformThreadId::UnderlyingType>);
-  if (GetCurrentProcId() == PlatformThread::CurrentId().raw()) {
+  if (GetCurrentProcId() == PlatformThread::CurrentId()) {
     // For the main thread we have a shortcut.
     return reinterpret_cast<uintptr_t>(__libc_stack_end);
   }

src/base/feature_list.cc

@@ -38,6 +38,7 @@
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "build/build_config.h"
+#include "build/chromeos_buildflags.h"
 
 namespace base {
 

src/base/feature_list.h

@@ -100,6 +100,9 @@ enum FeatureState {
 // `T` is a parameter type, one of bool, int, size_t, double, std::string, and
 // base::TimeDelta. Enum types are not supported for now.
 //
+// For now, ScopedFeatureList doesn't work to change the value dynamically when
+// the cache is used with this macro.
+//
 // It should *not* be defined in header files; do not use this macro in header
 // files.
 #define BASE_FEATURE_PARAM(T, feature_object_name, feature, name,       \

src/base/features.cc

@@ -4,9 +4,9 @@
 
 #include "base/features.h"
 
+#include "base/cpu_reduction_experiment.h"
 #include "base/task/sequence_manager/sequence_manager_impl.h"
 #include "base/threading/platform_thread.h"
-#include "build/blink_buildflags.h"
 #include "build/buildflag.h"
 
 #if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_ANDROID)
@@ -16,12 +16,8 @@
 #if BUILDFLAG(IS_APPLE)
 #include "base/files/file.h"
 #include "base/message_loop/message_pump_apple.h"
-#include "base/synchronization/condition_variable.h"
-
-#if !BUILDFLAG(IS_IOS) || !BUILDFLAG(USE_BLINK)
 #include "base/message_loop/message_pump_kqueue.h"
-#endif
-
+#include "base/synchronization/condition_variable.h"
 #endif
 
 #if BUILDFLAG(IS_ANDROID)
@@ -36,16 +32,23 @@ namespace base::features {
 
 // Alphabetical:
 
-// Controls caching within BASE_FEATURE_PARAM(). This is feature-controlled
-// so that ScopedFeatureList can disable it to turn off caching.
+// Activate base::FeatureParamWithCache internal cache.
+// TODO(https://crbug.com/340824113): Remove the feature flag below.
 BASE_FEATURE(kFeatureParamWithCache,
              "FeatureParamWithCache",
              FEATURE_ENABLED_BY_DEFAULT);
 
-// Use the Rust JSON parser. Enabled everywhere.
+// Use the Rust JSON parser. Enabled everywhere except Android, where the switch
+// from using the C++ parser in-thread to using the Rust parser in a thread-pool
+// introduces too much latency.
 BASE_FEATURE(kUseRustJsonParser,
              "UseRustJsonParser",
-             FEATURE_ENABLED_BY_DEFAULT);
+#if BUILDFLAG(IS_ANDROID)
+             FEATURE_DISABLED_BY_DEFAULT
+#else
+             FEATURE_ENABLED_BY_DEFAULT
+#endif  // BUILDFLAG(IS_ANDROID)
+);
 
 // If true, use the Rust JSON parser in-thread; otherwise, it runs in a thread
 // pool.
@@ -53,7 +56,7 @@ BASE_FEATURE_PARAM(bool,
                    kUseRustJsonParserInCurrentSequence,
                    &kUseRustJsonParser,
                    "UseRustJsonParserInCurrentSequence",
-                   true);
+                   false);
 
 // Use non default low memory device threshold.
 // Value should be given via |LowMemoryDeviceThresholdMB|.
@@ -122,6 +125,7 @@ BASE_FEATURE(kPostGetMyMemoryStateToBackground,
 
 void Init(EmitThreadControllerProfilerMetadata
               emit_thread_controller_profiler_metadata) {
+  InitializeCpuReductionExperiment();
   sequence_manager::internal::SequenceManagerImpl::InitializeFeatures();
   sequence_manager::internal::ThreadController::InitializeFeatures(
       emit_thread_controller_profiler_metadata);
@@ -137,14 +141,9 @@ void Init(EmitThreadControllerProfilerMetadata
 #if BUILDFLAG(IS_APPLE)
   File::InitializeFeatures();
   MessagePumpCFRunLoopBase::InitializeFeatures();
-
-// Kqueue is not used for ios blink.
-#if !BUILDFLAG(IS_IOS) || !BUILDFLAG(USE_BLINK)
   MessagePumpKqueue::InitializeFeatures();
 #endif
 
-#endif
-
 #if BUILDFLAG(IS_ANDROID)
   android::InputHintChecker::InitializeFeatures();
 #endif

src/base/files/file_path.cc

@@ -457,11 +457,6 @@ FilePath FilePath::InsertBeforeExtension(StringViewType suffix) const {
 
 FilePath FilePath::InsertBeforeExtensionASCII(std::string_view suffix) const {
   DCHECK(IsStringASCII(suffix));
-  return InsertBeforeExtensionUTF8(suffix);
-}
-
-FilePath FilePath::InsertBeforeExtensionUTF8(std::string_view suffix) const {
-  DCHECK(IsStringUTF8(suffix));
 #if BUILDFLAG(IS_WIN)
   return InsertBeforeExtension(UTF8ToWide(suffix));
 #elif BUILDFLAG(IS_POSIX) || BUILDFLAG(IS_FUCHSIA)
@@ -491,11 +486,6 @@ FilePath FilePath::AddExtension(StringViewType extension) const {
 
 FilePath FilePath::AddExtensionASCII(std::string_view extension) const {
   DCHECK(IsStringASCII(extension));
-  return AddExtensionUTF8(extension);
-}
-
-FilePath FilePath::AddExtensionUTF8(std::string_view extension) const {
-  DCHECK(IsStringUTF8(extension));
 #if BUILDFLAG(IS_WIN)
   return AddExtension(UTF8ToWide(extension));
 #elif BUILDFLAG(IS_POSIX) || BUILDFLAG(IS_FUCHSIA)
@@ -601,11 +591,6 @@ FilePath FilePath::Append(const SafeBaseName& component) const {
 
 FilePath FilePath::AppendASCII(std::string_view component) const {
   DCHECK(base::IsStringASCII(component));
-  return AppendUTF8(component);
-}
-
-FilePath FilePath::AppendUTF8(std::string_view component) const {
-  DCHECK(base::IsStringUTF8(component));
 #if BUILDFLAG(IS_WIN)
   return Append(UTF8ToWide(component));
 #elif BUILDFLAG(IS_POSIX) || BUILDFLAG(IS_FUCHSIA)

src/base/files/file_path.h

@@ -172,6 +172,9 @@ class BASE_EXPORT FilePath {
 
   using CharType = StringType::value_type;
   using StringViewType = std::basic_string_view<CharType>;
+  // DEPRECATED. Use `StringViewType` in new code.
+  // TODO(thestig): Remove.
+  using StringPieceType = StringViewType;
 
   // Null-terminated array of separators used to separate components in paths.
   // Each character in this array is a valid separator, but kSeparators[0] is
@@ -329,13 +332,6 @@ class BASE_EXPORT FilePath {
   [[nodiscard]] FilePath InsertBeforeExtensionASCII(
       std::string_view suffix) const;
 
-  // Like above, but takes the `suffix` as an UTF8 string.
-  // While all modern OSes support UTF-8, there is no requirement for the
-  // filenames to actually be UTF-8, e.g. on Linux. So inserting UTF-8 could
-  // result in Mojibake filenames.
-  [[nodiscard]] FilePath InsertBeforeExtensionUTF8(
-      std::string_view suffix) const;
-
   // Adds |extension| to |file_name|. Returns the current FilePath if
   // |extension| is empty. Returns "" if BaseName() == "." or "..".
   [[nodiscard]] FilePath AddExtension(StringViewType extension) const;
@@ -344,13 +340,6 @@ class BASE_EXPORT FilePath {
   // details on how this is handled.
   [[nodiscard]] FilePath AddExtensionASCII(std::string_view extension) const;
 
-  // Like above, but takes the extension as an UTF8 string. See AppendUTF8 for
-  // details on how this is handled.
-  // While all modern OSes support UTF-8, there is no requirement for the
-  // filenames to actually be UTF-8, e.g. on Linux. So appending UTF-8 could
-  // result in Mojibake filenames.
-  [[nodiscard]] FilePath AddExtensionUTF8(std::string_view extension) const;
-
   // Replaces the extension of |file_name| with |extension|.  If |file_name|
   // does not have an extension, then |extension| is added.  If |extension| is
   // empty, then the extension is removed from |file_name|.
@@ -383,12 +372,6 @@ class BASE_EXPORT FilePath {
   // system paths will always be ASCII.
   [[nodiscard]] FilePath AppendASCII(std::string_view component) const;
 
-  // Like above, but takes the `component` as an UTF8 string.
-  // While all modern OSes support UTF-8, there is no requirement for the
-  // filenames to actually be UTF-8, e.g. on Linux. So appending UTF-8 could
-  // result in Mojibake filenames.
-  [[nodiscard]] FilePath AppendUTF8(std::string_view component) const;
-
   // Returns true if this FilePath contains an absolute path.  On Windows, an
   // absolute path begins with either a drive letter specification followed by
   // a separator character, or with two separator characters.  On POSIX

src/base/files/file_util.h

@@ -428,7 +428,7 @@ BASE_EXPORT bool CreateTemporaryFileInDir(const FilePath& dir,
 // Returns the file name for a temporary file by using a platform-specific
 // naming scheme that incorporates |identifier|.
 BASE_EXPORT FilePath
-FormatTemporaryFileName(FilePath::StringViewType identifier);
+FormatTemporaryFileName(FilePath::StringPieceType identifier);
 
 // Create and open a temporary file stream for exclusive read, write, and delete
 // access. The full path is placed in `path`. Returns the opened file stream, or
@@ -463,7 +463,7 @@ BASE_EXPORT bool CreateNewTempDirectory(const FilePath::StringType& prefix,
 // Extra characters will be appended to |prefix| to ensure that the
 // new directory does not have the same name as an existing directory.
 BASE_EXPORT bool CreateTemporaryDirInDir(const FilePath& base_dir,
-                                         FilePath::StringViewType prefix,
+                                         FilePath::StringPieceType prefix,
                                          FilePath* new_dir);
 
 // Creates a directory, as well as creating any parent directories, if they

src/base/files/file_util_posix.cc

@@ -832,7 +832,7 @@ bool CreateTemporaryFileInDir(const FilePath& dir, FilePath* temp_file) {
   return fd.is_valid();
 }
 
-FilePath FormatTemporaryFileName(FilePath::StringViewType identifier) {
+FilePath FormatTemporaryFileName(FilePath::StringPieceType identifier) {
 #if BUILDFLAG(IS_APPLE)
   std::string_view prefix = base::apple::BaseBundleID();
 #elif BUILDFLAG(GOOGLE_CHROME_BRANDING)
@@ -881,7 +881,7 @@ static bool CreateTemporaryDirInDirImpl(const FilePath& base_dir,
 }
 
 bool CreateTemporaryDirInDir(const FilePath& base_dir,
-                             FilePath::StringViewType prefix,
+                             FilePath::StringPieceType prefix,
                              FilePath* new_dir) {
   FilePath::StringType mkdtemp_template(prefix);
   mkdtemp_template.append("XXXXXX");
@@ -902,25 +902,22 @@ bool CreateNewTempDirectory(const FilePath::StringType& prefix,
 bool CreateDirectoryAndGetError(const FilePath& full_path, File::Error* error) {
   ScopedBlockingCall scoped_blocking_call(
       FROM_HERE, BlockingType::MAY_BLOCK);  // For call to mkdir().
-  // Avoid checking subdirs if directory already exists.
-  if (DirectoryExists(full_path)) {
-    return true;
-  }
+  std::vector<FilePath> subpaths;
 
-  // Collect a list of all missing directories.
-  std::vector<FilePath> missing_subpaths({full_path});
+  // Collect a list of all parent directories.
   FilePath last_path = full_path;
+  subpaths.push_back(full_path);
   for (FilePath path = full_path.DirName(); path.value() != last_path.value();
        path = path.DirName()) {
-    if (DirectoryExists(path)) {
-      break;
-    }
-    missing_subpaths.push_back(path);
+    subpaths.push_back(path);
     last_path = path;
   }
 
-  // Iterate through the missing directories and create.
-  for (const FilePath& subpath : base::Reversed(missing_subpaths)) {
+  // Iterate through the parents and create the missing ones.
+  for (const FilePath& subpath : base::Reversed(subpaths)) {
+    if (DirectoryExists(subpath)) {
+      continue;
+    }
     if (mkdir(subpath.value().c_str(), 0700) == 0) {
       continue;
     }

src/base/files/file_util_win.cc

@@ -651,7 +651,7 @@ File CreateAndOpenTemporaryFileInDir(const FilePath& dir, FilePath* temp_file) {
       GetLongPathName(temp_name.value().c_str(), long_temp_name, MAX_PATH);
   if (long_name_len != 0 && long_name_len <= MAX_PATH) {
     *temp_file =
-        FilePath(FilePath::StringViewType(long_temp_name, long_name_len));
+        FilePath(FilePath::StringPieceType(long_temp_name, long_name_len));
   } else {
     // GetLongPathName() failed, but we still have a temporary file.
     *temp_file = std::move(temp_name);
@@ -664,7 +664,7 @@ bool CreateTemporaryFileInDir(const FilePath& dir, FilePath* temp_file) {
   return CreateAndOpenTemporaryFileInDir(dir, temp_file).IsValid();
 }
 
-FilePath FormatTemporaryFileName(FilePath::StringViewType identifier) {
+FilePath FormatTemporaryFileName(FilePath::StringPieceType identifier) {
   return FilePath(StrCat({identifier, FILE_PATH_LITERAL(".tmp")}));
 }
 
@@ -678,7 +678,7 @@ ScopedFILE CreateAndOpenTemporaryStreamInDir(const FilePath& dir,
 }
 
 bool CreateTemporaryDirInDir(const FilePath& base_dir,
-                             FilePath::StringViewType prefix,
+                             FilePath::StringPieceType prefix,
                              FilePath* new_dir) {
   ScopedBlockingCall scoped_blocking_call(FROM_HERE, BlockingType::MAY_BLOCK);
 
@@ -820,7 +820,7 @@ bool NormalizeFilePath(const FilePath& path, FilePath* real_path) {
   // with the volume device path and existing code expects we return a path
   // starting 'X:\' so we need to call DevicePathToDriveLetterPath.
   if (!DevicePathToDriveLetterPath(
-          FilePath(FilePath::StringViewType(native_file_path, used_wchars)),
+          FilePath(FilePath::StringPieceType(native_file_path, used_wchars)),
           real_path)) {
     return false;
   }
@@ -1092,7 +1092,7 @@ bool GetCurrentDirectory(FilePath* dir) {
   // TODO(evanm): the old behavior of this function was to always strip the
   // trailing slash.  We duplicate this here, but it shouldn't be necessary
   // when everyone is using the appropriate FilePath APIs.
-  *dir = FilePath(FilePath::StringViewType(system_buffer))
+  *dir = FilePath(FilePath::StringPieceType(system_buffer))
              .StripTrailingSeparators();
   return true;
 }

src/base/files/important_file_writer.cc

@@ -40,6 +40,7 @@
 #include "base/threading/thread.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
+#include "build/chromeos_buildflags.h"
 
 namespace base {
 
@@ -229,7 +230,7 @@ bool ImportantFileWriter::WriteFileAtomicallyImpl(
   base::debug::Alias(path_copy);
 #endif  // BUILDFLAG(IS_WIN) && DCHECK_IS_ON()
 
-#if BUILDFLAG(IS_CHROMEOS)
+#if BUILDFLAG(IS_CHROMEOS_ASH)
   // On Chrome OS, chrome gets killed when it cannot finish shutdown quickly,
   // and this function seems to be one of the slowest shutdown steps.
   // Include some info to the report for investigation. crbug.com/418627

src/base/files/safe_base_name.cc

@@ -20,7 +20,7 @@ std::optional<SafeBaseName> SafeBaseName::Create(const FilePath& path) {
 
 // static
 std::optional<SafeBaseName> SafeBaseName::Create(
-    FilePath::StringViewType path) {
+    FilePath::StringPieceType path) {
   return Create(FilePath(path));
 }
 

src/base/files/safe_base_name.h

@@ -29,8 +29,8 @@ class BASE_EXPORT SafeBaseName {
   // Factory method that returns a valid SafeBaseName or std::nullopt.
   static std::optional<SafeBaseName> Create(const FilePath&);
 
-  // Same as above, but takes a StringViewType for convenience.
-  static std::optional<SafeBaseName> Create(FilePath::StringViewType);
+  // Same as above, but takes a StringPieceType for convenience.
+  static std::optional<SafeBaseName> Create(FilePath::StringPieceType);
   const FilePath& path() const LIFETIME_BOUND { return path_; }
 
   // Convenience functions.

src/base/fuchsia/scoped_fx_logger.cc

@@ -118,11 +118,10 @@ void ScopedFxLogger::LogMessage(std::string_view file,
   // global logs to the system logger.
 
   fuchsia_syslog::LogBuffer buffer;
-  buffer.BeginRecord(fuchsia_severity,
-                     cpp17::string_view(file.data(), file.size()), line_number,
-                     cpp17::string_view(msg.data(), msg.size()),
-                     socket_.borrow(), 0, base::Process::Current().Pid(),
-                     base::PlatformThread::CurrentId().raw());
+  buffer.BeginRecord(
+      fuchsia_severity, cpp17::string_view(file.data(), file.size()),
+      line_number, cpp17::string_view(msg.data(), msg.size()), socket_.borrow(),
+      0, base::Process::Current().Pid(), base::PlatformThread::CurrentId());
   for (const auto& tag : tags_) {
     buffer.WriteKeyValue("tag", tag);
   }

src/base/functional/function_ref.h

@@ -6,6 +6,7 @@
 #define BASE_FUNCTIONAL_FUNCTION_REF_H_
 
 #include <concepts>
+#include <string_view>
 #include <type_traits>
 #include <utility>
 

src/base/i18n/file_util_icu.cc

@@ -23,6 +23,7 @@
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
+#include "build/chromeos_buildflags.h"
 #include "third_party/icu/source/common/unicode/uniset.h"
 #include "third_party/icu/source/i18n/unicode/coll.h"
 
@@ -311,7 +312,7 @@ bool LocaleAwareCompareFilenames(const FilePath& a, const FilePath& b) {
 }
 
 void NormalizeFileNameEncoding(FilePath* file_name) {
-#if BUILDFLAG(IS_CHROMEOS)
+#if BUILDFLAG(IS_CHROMEOS_ASH)
   std::string normalized_str;
   if (ConvertToUtf8AndNormalize(file_name->BaseName().value(), kCodepageUTF8,
                                 &normalized_str) &&

src/base/i18n/icu_util.h

@@ -10,6 +10,7 @@
 #include "base/files/memory_mapped_file.h"
 #include "base/i18n/base_i18n_export.h"
 #include "build/build_config.h"
+#include "build/chromeos_buildflags.h"
 
 #define ICU_UTIL_DATA_FILE 0
 #define ICU_UTIL_DATA_STATIC 1

src/base/i18n/time_formatting.cc

@@ -15,7 +15,7 @@
 #include "base/numerics/safe_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
-#include "build/build_config.h"
+#include "build/chromeos_buildflags.h"
 #include "third_party/icu/source/common/unicode/locid.h"
 #include "third_party/icu/source/common/unicode/utypes.h"
 #include "third_party/icu/source/i18n/unicode/datefmt.h"
@@ -169,7 +169,7 @@ std::u16string TimeFormatShortDateAndTimeWithTimeZone(const Time& time) {
   return TimeFormat(*formatter, time);
 }
 
-#if BUILDFLAG(IS_CHROMEOS)
+#if BUILDFLAG(IS_CHROMEOS_ASH)
 std::u16string TimeFormatMonthAndYearForTimeZone(
     const Time& time,
     const icu::TimeZone* time_zone) {

src/base/i18n/time_formatting.h

@@ -13,6 +13,7 @@
 
 #include "base/i18n/base_i18n_export.h"
 #include "build/build_config.h"
+#include "build/chromeos_buildflags.h"
 #include "third_party/icu/source/common/unicode/uversion.h"
 
 U_NAMESPACE_BEGIN
@@ -80,12 +81,12 @@ BASE_I18N_EXPORT std::u16string TimeFormatShortDateNumeric(const Time& time);
 // Returns a numeric date and time such as "12/13/52 2:44:30 PM".
 BASE_I18N_EXPORT std::u16string TimeFormatShortDateAndTime(const Time& time);
 
-#if BUILDFLAG(IS_CHROMEOS)
+#if BUILDFLAG(IS_CHROMEOS_ASH)
 // Returns a month and year, e.g. "November 2007" for the specified time zone.
 BASE_I18N_EXPORT std::u16string TimeFormatMonthAndYearForTimeZone(
     const Time& time,
     const icu::TimeZone* time_zone);
-#endif  // BUILDFLAG(IS_CHROMEOS)
+#endif  // BUILDFLAG(IS_CHROMEOS_ASH)
 
 // Returns a month and year, e.g. "November 2007"
 BASE_I18N_EXPORT std::u16string TimeFormatMonthAndYear(const Time& time);

src/base/json/json_parser.cc

@@ -2,6 +2,11 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#ifdef UNSAFE_BUFFERS_BUILD
+// TODO(crbug.com/40284755): Remove this and spanify to fix the errors.
+#pragma allow_unsafe_buffers
+#endif
+
 #include "base/json/json_parser.h"
 
 #include <algorithm>
@@ -12,7 +17,6 @@
 #include <vector>
 
 #include "base/check_op.h"
-#include "base/compiler_specific.h"
 #include "base/feature_list.h"
 #include "base/features.h"
 #include "base/json/json_reader.h"
@@ -200,7 +204,7 @@ std::optional<std::string_view> JSONParser::PeekChars(size_t count) {
   // restructured the code so that we only stored the remaining data, that
   // would avoid this, but it would prevent rewinding (the places in this file
   // which look at `input_[index_ - 1]`.)
-  return UNSAFE_BUFFERS(std::string_view(input_.data() + index_, count));
+  return std::string_view(input_.data() + index_, count);
 }
 
 std::optional<char> JSONParser::PeekChar() {
@@ -229,8 +233,7 @@ std::optional<char> JSONParser::ConsumeChar() {
 
 const char* JSONParser::pos() {
   CHECK_LE(index_, input_.length());
-  // SAFETY: Checked above.
-  return UNSAFE_BUFFERS(input_.data() + index_);
+  return input_.data() + index_;
 }
 
 JSONParser::Token JSONParser::GetNextToken() {

src/base/json/json_reader.cc

@@ -164,17 +164,6 @@ std::optional<Value::Dict> JSONReader::ReadDict(std::string_view json,
   return std::move(*value).TakeDict();
 }
 
-// static
-std::optional<Value::List> JSONReader::ReadList(std::string_view json,
-                                                int options,
-                                                size_t max_depth) {
-  std::optional<Value> value = Read(json, options, max_depth);
-  if (!value || !value->is_list()) {
-    return std::nullopt;
-  }
-  return std::move(*value).TakeList();
-}
-
 // static
 JSONReader::Result JSONReader::ReadAndReturnValueWithError(
     std::string_view json,

src/base/json/json_reader.h

@@ -123,13 +123,6 @@ class BASE_EXPORT JSONReader {
       int options = JSON_PARSE_CHROMIUM_EXTENSIONS,
       size_t max_depth = internal::kAbsoluteMaxDepth);
 
-  // Reads and parses |json|, returning a Value::List.
-  // If |json| is not a properly formed JSON list string, returns std::nullopt.
-  static std::optional<Value::List> ReadList(
-      std::string_view json,
-      int options = JSON_PARSE_CHROMIUM_EXTENSIONS,
-      size_t max_depth = internal::kAbsoluteMaxDepth);
-
   // Reads and parses |json| like Read(). On success returns a Value as the
   // expected value. Otherwise, it returns an Error instance, populated with a
   // formatted error message, an error code, and the error location if

src/base/json/string_escape.cc

@@ -131,18 +131,12 @@ bool EscapeJSONString(std::u16string_view str,
 
 std::string GetQuotedJSONString(std::string_view str) {
   std::string dest;
-  // The output will always be at least str.size() + 2 bytes for the quote
-  // characters.
-  dest.reserve(str.size() + 2);
   EscapeJSONStringImpl(str, true, &dest);
   return dest;
 }
 
 std::string GetQuotedJSONString(std::u16string_view str) {
   std::string dest;
-  // The output will always be at least str.size() + 2 bytes for the quote
-  // characters.
-  dest.reserve(str.size() + 2);
   EscapeJSONStringImpl(str, true, &dest);
   return dest;
 }

src/base/linux_util.cc

@@ -33,12 +33,13 @@
 #include "base/strings/string_tokenizer.h"
 #include "base/strings/string_util.h"
 #include "build/build_config.h"
+#include "build/chromeos_buildflags.h"
 
 namespace base {
 
 namespace {
 
-#if !BUILDFLAG(IS_CHROMEOS)
+#if !BUILDFLAG(IS_CHROMEOS_ASH)
 std::string GetKeyValueFromOSReleaseFile(const std::string& input,
                                          const char* key) {
   StringPairs key_value_pairs;
@@ -96,7 +97,7 @@ class DistroNameGetter {
     }
   }
 };
-#endif  // !BUILDFLAG(IS_CHROMEOS)
+#endif  // !BUILDFLAG(IS_CHROMEOS_ASH)
 
 bool GetThreadsFromProcessDir(const char* dir_path, std::vector<pid_t>* tids) {
   DirReaderPosix dir_reader(dir_path);
@@ -124,7 +125,7 @@ constexpr int kDistroSize = 128 + 1;
 // We use this static string to hold the Linux distro info. If we
 // crash, the crash handler code will send this in the crash dump.
 char g_linux_distro[kDistroSize] =
-#if BUILDFLAG(IS_CHROMEOS)
+#if BUILDFLAG(IS_CHROMEOS_ASH)
     "CrOS";
 #elif BUILDFLAG(IS_ANDROID)
     "Android";
@@ -140,15 +141,15 @@ char g_linux_distro[kDistroSize] =
 BASE_EXPORT std::string GetKeyValueFromOSReleaseFileForTesting(
     const std::string& input,
     const char* key) {
-#if !BUILDFLAG(IS_CHROMEOS)
+#if !BUILDFLAG(IS_CHROMEOS_ASH)
   return GetKeyValueFromOSReleaseFile(input, key);
 #else
   return "";
-#endif  // !BUILDFLAG(IS_CHROMEOS)
+#endif  // !BUILDFLAG(IS_CHROMEOS_ASH)
 }
 
 std::string GetLinuxDistro() {
-#if !BUILDFLAG(IS_CHROMEOS)
+#if !BUILDFLAG(IS_CHROMEOS_ASH)
   // We do this check only once per process. If it fails, there's
   // little reason to believe it will work if we attempt to run it again.
   static DistroNameGetter distro_name_getter;

src/base/location.cc

@@ -2,6 +2,11 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#ifdef UNSAFE_BUFFERS_BUILD
+// TODO(crbug.com/40284755): Remove this and spanify to fix the errors.
+#pragma allow_unsafe_buffers
+#endif
+
 #include "base/location.h"
 
 #include "base/compiler_specific.h"
@@ -20,7 +25,7 @@ namespace {
 // Returns the length of the given null terminated c-string.
 constexpr size_t StrLen(const char* str) {
   size_t str_len = 0;
-  for (str_len = 0; UNSAFE_TODO(str[str_len]) != '\0'; ++str_len)
+  for (str_len = 0; str[str_len] != '\0'; ++str_len)
     ;
   return str_len;
 }
@@ -58,7 +63,7 @@ constexpr bool StrEndsWith(const char* name,
     return false;
   }
   for (size_t i = 0; i < expected_len; ++i) {
-    if (UNSAFE_TODO(name[i + prefix_len] != expected[i])) {
+    if (name[i + prefix_len] != expected[i]) {
       return false;
     }
   }
@@ -130,15 +135,15 @@ void Location::WriteIntoTrace(perfetto::TracedValue context) const {
 NOINLINE Location Location::Current(const char* function_name,
                                     const char* file_name,
                                     int line_number) {
-  return Location(function_name, UNSAFE_TODO(file_name + kStrippedPrefixLength),
-                  line_number, RETURN_ADDRESS());
+  return Location(function_name, file_name + kStrippedPrefixLength, line_number,
+                  RETURN_ADDRESS());
 }
 
 // static
 NOINLINE Location Location::CurrentWithoutFunctionName(const char* file_name,
                                                        int line_number) {
-  return Location(nullptr, UNSAFE_TODO(file_name + kStrippedPrefixLength),
-                  line_number, RETURN_ADDRESS());
+  return Location(nullptr, file_name + kStrippedPrefixLength, line_number,
+                  RETURN_ADDRESS());
 }
 
 //------------------------------------------------------------------------------

src/base/logging.cc

@@ -2,6 +2,11 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#ifdef UNSAFE_BUFFERS_BUILD
+// TODO(crbug.com/40284755): Remove this and spanify to fix the errors.
+#pragma allow_unsafe_buffers
+#endif
+
 #include "base/logging.h"
 
 #include <limits.h>
@@ -23,7 +28,6 @@
 #include "base/base_export.h"
 #include "base/base_switches.h"
 #include "base/command_line.h"
-#include "base/compiler_specific.h"
 #include "base/containers/stack.h"
 #include "base/debug/alias.h"
 #include "base/debug/crash_logging.h"
@@ -51,6 +55,7 @@
 #include "base/trace_event/base_tracing.h"
 #include "base/vlog.h"
 #include "build/build_config.h"
+#include "build/chromeos_buildflags.h"
 #include "third_party/abseil-cpp/absl/base/internal/raw_logging.h"
 #include "third_party/abseil-cpp/absl/cleanup/cleanup.h"
 
@@ -110,7 +115,7 @@ typedef FILE* FileHandle;
 #include "base/android/jni_android.h"
 #endif
 
-#if BUILDFLAG(IS_CHROMEOS)
+#if BUILDFLAG(IS_CHROMEOS_ASH)
 #include "base/files/scoped_file.h"
 #endif
 
@@ -203,7 +208,7 @@ static_assert(LOGGING_NUM_SEVERITIES == std::size(log_severity_names),
 
 const char* log_severity_name(int severity) {
   if (severity >= 0 && severity < LOGGING_NUM_SEVERITIES) {
-    return UNSAFE_TODO(log_severity_names[severity]);
+    return log_severity_names[severity];
   }
   return "UNKNOWN";
 }
@@ -431,8 +436,7 @@ void WriteToFd(int fd, const char* data, size_t length) {
   size_t bytes_written = 0;
   long rv;
   while (bytes_written < length) {
-    rv = HANDLE_EINTR(
-        write(fd, UNSAFE_TODO(data + bytes_written), length - bytes_written));
+    rv = HANDLE_EINTR(write(fd, data + bytes_written, length - bytes_written));
     if (rv < 0) {
       // Give up, nothing we can do now.
       break;
@@ -476,7 +480,7 @@ std::string BuildCrashString(const char* file,
 #endif  // BUILDFLAG(IS_WIN)
     );
     if (slash) {
-      file = UNSAFE_TODO(slash + 1);
+      file = slash + 1;
     }
   }
 
@@ -548,13 +552,13 @@ bool BaseInitLoggingImpl(const LoggingSettings& settings) {
   // default log file will re-initialize to the new options.
   CloseLogFileUnlocked();
 
-#if BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_WIN)
+#if BUILDFLAG(IS_CHROMEOS_ASH) || BUILDFLAG(IS_WIN)
   if (settings.log_file) {
     CHECK(settings.log_file_path.empty(), base::NotFatalUntil::M127);
     g_log_file = settings.log_file;
     return true;
   }
-#endif  // BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_WIN)
+#endif  // BUILDFLAG(IS_CHROMEOS_ASH) || BUILDFLAG(IS_WIN)
 
   CHECK(!settings.log_file_path.empty(), base::NotFatalUntil::M127)
       << "LOG_TO_FILE set but no log_file_path!";
@@ -952,7 +956,7 @@ void LogMessage::Flush() {
 
 std::string LogMessage::BuildCrashString() const {
   return logging::BuildCrashString(file(), line(),
-                                   UNSAFE_TODO(str().c_str() + message_start_));
+                                   str().c_str() + message_start_);
 }
 
 // writes the common header info to the stream
@@ -1171,7 +1175,7 @@ void CloseLogFile() {
   CloseLogFileUnlocked();
 }
 
-#if BUILDFLAG(IS_CHROMEOS)
+#if BUILDFLAG(IS_CHROMEOS_ASH)
 FILE* DuplicateLogFILE() {
   if ((g_logging_destination & LOG_TO_FILE) == 0 ||
       !InitializeLogFileHandle()) {
@@ -1219,7 +1223,7 @@ ScopedLoggingSettings::ScopedLoggingSettings()
       logging_destination_(g_logging_destination),
 #if BUILDFLAG(IS_CHROMEOS)
       log_format_(g_log_format),
-#endif  // BUILDFLAG(IS_CHROMEOS)
+#endif  // BUILDFLAG(IS_CHROMEOS_ASH)
       enable_process_id_(g_log_process_id),
       enable_thread_id_(g_log_thread_id),
       enable_timestamp_(g_log_timestamp),
@@ -1261,14 +1265,14 @@ ScopedLoggingSettings::~ScopedLoggingSettings() {
 void ScopedLoggingSettings::SetLogFormat(LogFormat log_format) const {
   g_log_format = log_format;
 }
-#endif  // BUILDFLAG(IS_CHROMEOS)
+#endif  // BUILDFLAG(IS_CHROMEOS_ASH)
 
 void RawLog(int level, const char* message) {
   if (level >= g_min_log_level && message) {
     const size_t message_len = strlen(message);
     WriteToFd(STDERR_FILENO, message, message_len);
 
-    if (message_len > 0 && UNSAFE_TODO(message[message_len - 1]) != '\n') {
+    if (message_len > 0 && message[message_len - 1] != '\n') {
       long rv;
       do {
         rv = HANDLE_EINTR(write(STDERR_FILENO, "\n", 1));

src/base/logging.h

@@ -21,8 +21,6 @@
 #include "base/logging/log_severity.h"
 #include "base/strings/utf_ostream_operators.h"
 #include "build/build_config.h"
-// TODO(crbug.com/354842935): Remove this include once other files don't
-// accidentally (transitively) depend on it anymore.
 #include "build/chromeos_buildflags.h"
 
 #if BUILDFLAG(IS_CHROMEOS)
@@ -730,7 +728,7 @@ class BASE_EXPORT ErrnoLogMessageFatal final : public ErrnoLogMessage {
 //       after this call.
 BASE_EXPORT void CloseLogFile();
 
-#if BUILDFLAG(IS_CHROMEOS)
+#if BUILDFLAG(IS_CHROMEOS_ASH)
 // Returns a new file handle that will write to the same destination as the
 // currently open log file. Returns nullptr if logging to a file is disabled,
 // or if opening the file failed. This is intended to be used to initialize

src/base/memory/MIRACLE_PTR_OWNERS

@@ -1,4 +1,5 @@
 arthursonzogni@chromium.org
+bartekn@chromium.org
 dcheng@chromium.org
 glazunov@google.com
 keishi@chromium.org

src/base/memory/post_delayed_memory_reduction_task.cc

@@ -105,7 +105,8 @@ class OneShotDelayedBackgroundTimer::TaskImpl final
       Stop();
     }
     DCHECK(GetTaskRunner()->RunsTasksInCurrentSequence());
-    base::AutoLock locker(android::PreFreezeBackgroundMemoryTrimmer::lock());
+    base::AutoLock locker(
+        android::PreFreezeBackgroundMemoryTrimmer::Instance().lock_);
     task_ = android::PreFreezeBackgroundMemoryTrimmer::Instance()
                 .PostDelayedBackgroundTaskModernHelper(
                     GetTaskRunner(), from_here, std::move(task), delay);

src/base/memory/raw_ptr.md

@@ -57,7 +57,7 @@ remains an Undefined Behavior.
 `raw_ptr<T>` protection is enabled by default in all non-Renderer processes, on:
 - Android (incl. AndroidWebView, Android WebEngine, & Android ChromeCast)
 - Windows
-- ChromeOS
+- ChromeOS (incl. Ash & Lacros)
 - macOS
 - Linux
 - Fuchsia

src/base/memory/weak_ptr.h

@@ -85,6 +85,13 @@
 #include "base/sequence_checker.h"
 #include "base/synchronization/atomic_flag.h"
 
+namespace performance_manager {
+class FrameNodeImpl;
+class PageNodeImpl;
+class ProcessNodeImpl;
+class WorkerNodeImpl;
+}  // namespace performance_manager
+
 namespace base {
 
 namespace sequence_manager::internal {
@@ -341,6 +348,10 @@ class BASE_EXPORT BindWeakPtrFactoryPassKey {
   BindWeakPtrFactoryPassKey() = default;
 
   friend class BindWeakPtrFactoryForTesting;
+  friend class performance_manager::FrameNodeImpl;
+  friend class performance_manager::PageNodeImpl;
+  friend class performance_manager::ProcessNodeImpl;
+  friend class performance_manager::WorkerNodeImpl;
   friend class sequence_manager::internal::TaskQueueImpl;
 };
 

src/base/message_loop/message_pump_for_io.h

@@ -9,15 +9,12 @@
 // types representing MessagePumpForIO.
 
 #include "base/message_loop/ios_cronet_buildflags.h"
-#include "build/blink_buildflags.h"
 #include "build/build_config.h"
 
 #if BUILDFLAG(IS_WIN)
 #include "base/message_loop/message_pump_win.h"
 #elif BUILDFLAG(IS_IOS) && BUILDFLAG(CRONET_BUILD)
 #include "base/message_loop/message_pump_io_ios.h"
-#elif BUILDFLAG(IS_IOS) && BUILDFLAG(USE_BLINK)
-#include "base/message_loop/message_pump_io_ios_libdispatch.h"
 #elif BUILDFLAG(IS_APPLE)
 #include "base/message_loop/message_pump_kqueue.h"
 #elif BUILDFLAG(IS_NACL)
@@ -35,8 +32,6 @@ namespace base {
 using MessagePumpForIO = MessagePumpForIO;
 #elif BUILDFLAG(IS_IOS) && BUILDFLAG(CRONET_BUILD)
 using MessagePumpForIO = MessagePumpIOSForIO;
-#elif BUILDFLAG(IS_IOS) && BUILDFLAG(USE_BLINK)
-using MessagePumpForIO = MessagePumpIOSForIOLibdispatch;
 #elif BUILDFLAG(IS_APPLE)
 using MessagePumpForIO = MessagePumpKqueue;
 #elif BUILDFLAG(IS_NACL)

src/base/message_loop/message_pump_glib.cc

@@ -53,7 +53,7 @@ int GetTimeIntervalMilliseconds(TimeTicks next_task_time) {
 
 bool RunningOnMainThread() {
   auto pid = getpid();
-  auto tid = PlatformThread::CurrentId().raw();
+  auto tid = PlatformThread::CurrentId();
   return pid > 0 && tid > 0 && pid == tid;
 }
 

src/base/message_loop/message_pump_io_ios_libdispatch.cc

@@ -1,212 +0,0 @@
-// Copyright 2025 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/message_loop/message_pump_io_ios_libdispatch.h"
-
-namespace base {
-
-MessagePumpIOSForIOLibdispatch::FdWatchController::FdWatchController(
-    const Location& location)
-    : FdWatchControllerInterface(location) {}
-
-MessagePumpIOSForIOLibdispatch::FdWatchController::~FdWatchController() {
-  StopWatchingFileDescriptor();
-}
-
-bool MessagePumpIOSForIOLibdispatch::FdWatchController::
-    StopWatchingFileDescriptor() {
-  watcher_ = nullptr;
-  fd_ = -1;
-  dispatch_source_read_.reset();
-  dispatch_source_write_.reset();
-  return true;
-}
-
-void MessagePumpIOSForIOLibdispatch::FdWatchController::Init(
-    const scoped_refptr<base::SequencedTaskRunner>& io_thread_task_runner,
-    dispatch_queue_t queue,
-    int fd,
-    bool persistent,
-    int mode,
-    FdWatcher* watcher) {
-  DCHECK(io_thread_task_runner->RunsTasksInCurrentSequence());
-  DCHECK(watcher);
-  DCHECK(!watcher_);
-  is_persistent_ = persistent;
-  io_thread_task_runner_ = io_thread_task_runner;
-  fd_ = fd;
-  watcher_ = watcher;
-  base::WeakPtr<MessagePumpIOSForIOLibdispatch::FdWatchController> weak_this =
-      weak_factory_.GetWeakPtr();
-  DCHECK(mode == WATCH_READ || mode == WATCH_WRITE || mode == WATCH_READ_WRITE);
-
-  if (mode == WATCH_READ || mode == WATCH_READ_WRITE) {
-    dispatch_source_read_ = std::make_unique<
-        apple::DispatchSource>(queue, fd, DISPATCH_SOURCE_TYPE_READ, ^{
-      if (fd_ == -1) {
-        return;
-      }
-      dispatch_source_read_->Suspend();
-      io_thread_task_runner_->PostTask(
-          FROM_HERE,
-          base::BindOnce(
-              &MessagePumpIOSForIOLibdispatch::FdWatchController::HandleRead,
-              weak_this));
-    });
-    dispatch_source_read_->Resume();
-  }
-  if (mode == WATCH_WRITE || mode == WATCH_READ_WRITE) {
-    dispatch_source_write_ = std::make_unique<
-        apple::DispatchSource>(queue, fd, DISPATCH_SOURCE_TYPE_WRITE, ^{
-      if (fd_ == -1) {
-        return;
-      }
-      dispatch_source_write_->Suspend();
-      io_thread_task_runner_->PostTask(
-          FROM_HERE,
-          base::BindOnce(
-              &MessagePumpIOSForIOLibdispatch::FdWatchController::HandleWrite,
-              weak_this));
-    });
-    dispatch_source_write_->Resume();
-  }
-}
-
-void MessagePumpIOSForIOLibdispatch::FdWatchController::HandleRead() {
-  DCHECK(io_thread_task_runner_->RunsTasksInCurrentSequence());
-  if (watcher_) {
-    base::WeakPtr<MessagePumpIOSForIOLibdispatch::FdWatchController> weak_this =
-        weak_factory_.GetWeakPtr();
-    watcher_->OnFileCanReadWithoutBlocking(fd_);
-    if (!weak_this) {
-      return;
-    }
-  }
-  if (!is_persistent_) {
-    StopWatchingFileDescriptor();
-  }
-  if (dispatch_source_read_) {
-    dispatch_source_read_->Resume();
-  }
-}
-
-void MessagePumpIOSForIOLibdispatch::FdWatchController::HandleWrite() {
-  DCHECK(io_thread_task_runner_->RunsTasksInCurrentSequence());
-  if (watcher_) {
-    base::WeakPtr<MessagePumpIOSForIOLibdispatch::FdWatchController> weak_this =
-        weak_factory_.GetWeakPtr();
-    watcher_->OnFileCanWriteWithoutBlocking(fd_);
-    if (!weak_this) {
-      return;
-    }
-  }
-  if (!is_persistent_) {
-    StopWatchingFileDescriptor();
-  }
-  if (dispatch_source_write_) {
-    dispatch_source_write_->Resume();
-  }
-}
-
-MessagePumpIOSForIOLibdispatch::MachPortWatchController::
-    MachPortWatchController(const Location& location) {}
-
-MessagePumpIOSForIOLibdispatch::MachPortWatchController::
-    ~MachPortWatchController() {
-  StopWatchingMachPort();
-}
-
-bool MessagePumpIOSForIOLibdispatch::MachPortWatchController::
-    StopWatchingMachPort() {
-  port_ = MACH_PORT_NULL;
-  watcher_ = nullptr;
-  dispatch_source_.reset();
-  return true;
-}
-
-void MessagePumpIOSForIOLibdispatch::MachPortWatchController::Init(
-    const scoped_refptr<base::SequencedTaskRunner>& io_thread_task_runner,
-    dispatch_queue_t queue,
-    mach_port_t port,
-    MachPortWatcher* watcher) {
-  DCHECK(io_thread_task_runner->RunsTasksInCurrentSequence());
-  DCHECK(watcher);
-  DCHECK(!watcher_);
-  watcher_ = watcher;
-  port_ = port;
-  io_thread_task_runner_ = io_thread_task_runner;
-  base::WeakPtr<MessagePumpIOSForIOLibdispatch::MachPortWatchController>
-      weak_this = weak_factory_.GetWeakPtr();
-  dispatch_source_ = std::make_unique<apple::DispatchSource>(queue, port, ^{
-    if (port_ == MACH_PORT_NULL) {
-      return;
-    }
-    dispatch_source_->Suspend();
-    io_thread_task_runner_->PostTask(
-        FROM_HERE, base::BindOnce(&MessagePumpIOSForIOLibdispatch::
-                                      MachPortWatchController::HandleReceive,
-                                  weak_this));
-  });
-  dispatch_source_->Resume();
-}
-
-void MessagePumpIOSForIOLibdispatch::MachPortWatchController::HandleReceive() {
-  DCHECK(io_thread_task_runner_->RunsTasksInCurrentSequence());
-  base::WeakPtr<MessagePumpIOSForIOLibdispatch::MachPortWatchController>
-      weak_this = weak_factory_.GetWeakPtr();
-  watcher_->OnMachMessageReceived(port_);
-  if (!weak_this) {
-    return;
-  }
-  if (dispatch_source_) {
-    dispatch_source_->Resume();
-  }
-}
-
-MessagePumpIOSForIOLibdispatch::MessagePumpIOSForIOLibdispatch()
-    : queue_(dispatch_queue_create("org.chromium.io_thread.libdispatch_bridge",
-                                   DISPATCH_QUEUE_SERIAL)) {}
-
-MessagePumpIOSForIOLibdispatch::~MessagePumpIOSForIOLibdispatch() {
-  dispatch_release(queue_);
-}
-
-bool MessagePumpIOSForIOLibdispatch::WatchFileDescriptor(
-    int fd,
-    bool persistent,
-    int mode,
-    FdWatchController* controller,
-    FdWatcher* watcher) {
-  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
-  DCHECK_GE(fd, 0);
-  DCHECK(controller);
-  DCHECK(watcher);
-  DCHECK(mode == WATCH_READ || mode == WATCH_WRITE || mode == WATCH_READ_WRITE);
-
-  // WatchFileDescriptor is allowed to be called again if the file handle
-  // matches the one that is currently bound.
-  if (controller->fd() != -1 && controller->fd() != fd) {
-    return false;
-  }
-  controller->StopWatchingFileDescriptor();
-
-  controller->Init(SequencedTaskRunner::GetCurrentDefault(), queue_, fd,
-                   persistent, mode, watcher);
-  return true;
-}
-
-bool MessagePumpIOSForIOLibdispatch::WatchMachReceivePort(
-    mach_port_t port,
-    MachPortWatchController* controller,
-    MachPortWatcher* watcher) {
-  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
-  DCHECK_NE(port, static_cast<mach_port_t>(MACH_PORT_NULL));
-  DCHECK(controller);
-  DCHECK(watcher);
-  controller->Init(SequencedTaskRunner::GetCurrentDefault(), queue_, port,
-                   watcher);
-  return true;
-}
-
-}  // namespace base